
Every time you want to start something new, there is a deep urge to plan. But **not** to make general planning. Instead, we want to plan deep and complex stuff.

Sometimes, this ends well, especially if the feature or project isn’t too big or complex.

But how this ends when a feature is complex with many unknowns is a different thing. Even when you think that you know everything, you probably don’t. And even if you do, there is a much better and cleaner way to do it.

So there are actually two ways to go about this. Plan as long as you want but keep your mind open for changes or don’t plan too much.

Personally, I mostly like to plan for the sake of planning. Because when I plan in my head there aren’t unknowns. I can come up with the perfect solution.

Once I know what the perfect world seems like, I will try to make the real-world thing as similar as possible to my imagination.

But not everything is fun to plan, there are features that are complex as a result. They aren’t fun to plan.

In this case, I am diving directly in. I have a small picture of the thing that I want to build, and I start writing code.

Always taking the most naive road at first, until I overcame all the obstacles. Once the obstacles are gone, I have zero unknowns. At this point, I start to think, if that was the best way to accomplish this result.

In the end, I always refactor everything multiple times until I have a result that I am satisfied with.


Every time you want to start something new, there is a deep urge to plan, but not to make general planning. Instead, we want to plan deep.

You can't plan everything upfront


Since I was a kid I always admired how smart the Google search engine was. It always knew what I was looking for even before me.

Actually searching is one thing I love about technology.

When I am in a big store and I am searching for a concrete product and I have no idea where it is. I always wish there was a search input at the entrance where I type what I am looking for, and find its exact position.

But those things would never convince me to build Sigmie.

In the last 5 years, I worked at 4 companies, and all had the same problem. “The search”.

Either it was slow, expensive, or not smart enough, or it destroyed the database because of too the many indexes on too many columns.

And my experience with Elasticsearch made me wonder why people aren’t using it to solve their Search problems.

Now after trying to figure things out for 3 years I know some of the reasons.

But the most important reason is that people want something that "just works”. While an application has a million things to focus. For most businesses, there is no time to set up and maintain something  Elasticsearch.

Of course, the same goes for me. Even though I have a lot of experience with using Elasticsearch. I rarely use it on production for searching, because there is never time for it.

So the main reason for building Sigmie is to “scratch my own itch” and easily set up searches even for smaller projects.


The reason that pushed me to create Sigmie

Why I created Sigmie


A thing in all my projects is using Elastic cloud for my application logging.

The reason for this is that, it’s super easy to start logging in [Elastic](https://www.elastic.co/de/) with Laravel. With ~20$ a month you can have a small Elasticsearch & Kibana setup ready the receive logs from your application.

Now let me show you how to do this.

First you need to require the official Elasticsearch library 

```bash
$ composer require elasticsearch/elasticsearch
```

Next we add an `elastic` custom logging driver to `config/logging.php` file

```php
'elastic' => [
            'driver' => 'custom',
            'via'    => \App\Logging\ElasticLogger::class,
            'cloud_id' => env('ELASTIC_CLOUD_ID', null),
            'password' => env('ELASTIC_PASSWORD', null),            
            'prefix' => env('ELASTIC_INDEX_PREFIX', \Illuminate\Support\Str::slug(env('APP_NAME', 'laravel'), '_')),
        ],
```

and we create our **custom** `ElasticLogger` class in `app/Logging/ElasticLogger.php` with the following

```php
<?php

namespace App\Logging;

use Carbon\Carbon;
use Monolog\Formatter\ElasticsearchFormatter;
use Monolog\Handler\ElasticsearchHandler;
use Psr\Log\LoggerInterface;
use Elasticsearch\ClientBuilder;
use Illuminate\Log\Logger;
use Monolog\Logger as MonologLogger;

class ElasticLogger
{
    public function __invoke(array $config): LoggerInterface
    {
        $index =  $config['prefix'] . '_' . Carbon::now()->format('Y_m_d');

        $client = ClientBuilder::create()
            ->setElasticCloudId($config['cloud_id'])
            ->setBasicAuthentication('elastic', $config['password'])
            ->build();

        $handler = new ElasticsearchHandler($client);
        $handler->setFormatter(new ElasticsearchFormatter($index, '_doc'));

        $monolog = new MonologLogger('elastic', [$handler]);

        return (new Logger($monolog))->withContext(['env' => config('app.env')]);
    }
}
```

And last we update our environment variables

```php
LOG_CHANNEL=elastic
ELASTIC_PASSWORD=
ELASTIC_CLOUD_ID=
```

You will find the **Elastic Password** and your **Cloud Id** in the [Elastic.co deployment](https://cloud.elastic.co/).

Now you can use the `Log` facade and all logs from your application will land at one place.

For example
```php
Log::info('New Order!', [ 'price' => $order->total ]);
```

You can use this to create various Dashboards for Error reporting und much more stuff.

In another post I will show you how you can auto delete you indices once they are older than a week.


Log from your Laravel app into Elastic Cloud from all your environments.

Elastic logger for Laravel


## Why transactions are a good thing.
Let’s say that in your application all users have to belong to a team. And in your `createUser` action, you create a user and then you assign this user a team. 
```php
$user = User::create(['email'=> 'john@gmai.com');

$user->teams()->attach($team->id); //Throws an exception
```

If you get an Exception while attaching the `Team` to the `User`, your application ends with a wrong state where you have a `User` which hasn’t a `Team` assigned.

This is simple to fix in this case, but it can be more complex in other cases and by using database transactions will yourself these state fixes. Because, when using database transactions, if the team assignment throws an exception, your application will also prevent the user creation.

## How to implement write transactions in Laravel
Database transactions are good practice for all **write** actions. Therefore we create a global middleware for this, using the following command. 
```bash
$ php artisan make:middleware DatabaseTransaction
```

and we change the `handle` method like below:
```php
//app/Http/Middleware/DatabaseTransaction.php

public function handle($request, \Closure $next)
{
		if (!in_array($request->method(),['POST','PUT','PATCH','DELETE'])) {
			return $next($request);
		}

		DB::beginTransaction();

    try {
        $response = $next($request);
    } catch (\Exception $e) {

        DB::rollBack();

        throw $e;
    }
	
    if ($response->getStatusCode() > 399) {
        DB::rollBack();
    } else {
        DB::commit();
    }

    return $response;
}
```

This code will check if we make a **write** operation by checking if the **request method** of the request is a **write** one, and start a transaction. If within the **write** request something goes wrong it will roll back the transaction.

The only thing left to do is to register the middleware to our `web` middleware group in the  `app/Http/Kernel.php`. 

```php
//app/Http/Kernel.php

protected $middlewareGroups = [
    'web' => [
			// ...
			\App\Http\Middleware\DatabaseTransaction::class
    ],
];
```

Now your application will use this `DatabaseTransaction` middleware on every request.

## What to keep in mind
Once you have fully integrated database transactions in your applications, there is this one thing that you need to watch out for when dispatching jobs. If you dispatch a job and later your application rolls back, your job **will still be processed** by your queue. 

For that reason, Laravel has the [afterCommit](https://laravel.com/docs/8.x/queues#specifying-commit-dispatch-behavior-inline)  method which you can chain after the `dispatch`. This way you are safe that the dispatch will only run if the response was successful. 

So if you also are sending an email after the user creation, your code should look like this:

```php
$user = User::create(['email'=> 'john@gmai.com');
    
$user->teams()->attach($team->id);

dispatch(new SendWelcomeEmail($user))->afterCommit();
```

## Final words

The accuracy, completeness, and reliability of your database data are viable things for your application. Using database transactions in Laravel is easy for us to take advantage of them.


Using database transactions can give you database integrity, and it’s a good practice to use them for your write operations. Let’s see why and how you can use them in your Laravel application.

Using database transactions for write operations


Inspired by many others I listed the software tools that I use, and also how I use them.

### Editor
I use Microsoft’s [VSCode](https://code.visualstudio.com/) for the coding. What I mostly love about it is the “Remote Containers” extension. Since I’m mostly working with docker, and I am also switching a lot between projects, I like to open each project in my editor and have all the docker containers started.

### Database
For database management, I am using [TablePlus](h). Very important for me are the security modes, since I toggle a lot between production, stage, and local databases. These modes already saved me a few times from accidentally running queries on the wrong environment. 

### Git
I’m only using *git* on the command line without any visual tools. Most UI tools for git always feel slow for me. I have two favorite commands aliased.

## HTTP
Since I am working daily with REST APIs, I use [Insomnia](https://insomnia.rest/) for testing my requests. Quite often I find myself copying AJAX requests as CURL from devtools and pasting it to Insomnia for debugging. 

### Notes
For note-taking and also generally for my writing I am using [Bear](https://bear.app/). It’s an elegant tool for writing without distractions.

### Terminal
As a terminal fan, I am using [iTerm2](https://iterm2.com/) as a dropdown terminal combined with [tmux](https://wiki.archlinux.org/title/tmux), which allows me to split my terminal windows. It’s very handy if you are observing logs from different applications.  

### TODOs
[Things3](https://culturedcode.com/things/) is my to-do application; there I am writing anything that comes to my mind, which I want to remember. During a coding session, I may remember that I want to refactor a function or write a test for a class. By pressing `opt + .`  the “Quick entry” appears; there I can quickly write my thought and return to whatever I was doing.


Inspired by many others I listed the software tools that I use, and also how I use them.

What I use


I was building a daily I product which I had no idea what it should look like at the end. But I kept going and I learned a lesson.

In 2019 I wanted to make an Elasticsearch library for PHP. Even though there were already some of them, none of the existing libraries covered￼ what I was expecting. With some interaction that I had with Elasticsearch, I was amazed. All the tools for building a search experience in one, and Open Source.

I started building it, and soon enough I needed a server. For this,  I wrote a script that creates an Elasticsearch server.  After I created a UI  and then I added more stuff, and more stuff. I started adding functions like subscription and authentication, but I had no idea about what I was building. 

I had a lot of ideas, that came from podcasts and other applications I was using, but how could I combine all of them into one product.

And for 2 years this question remained unanswered for me, while I was continuously building and creating stuff, which I thought was useful. 

Finally, before 3 weeks, it became clear,  from this point it’s just a matter of time until I can launch it and tell people about it.

I am writing this to share my experience and to point that it’s important to get started without having the full plan. Don’t wait until you are ready, just start. And at some point, everything will become clear.

For me, it took 2 years…


I was building a daily I product which I had no idea what it should look like at the end. But I kept going and I learned a lesson.

For two years I had no idea what I was building


## Introduction

Tailwind recently released their JIT compiler, which much more flexibility
when encountering edge cases during your development. It allows you to use
class names like `bg-[#00acee]`, `w-[200px]` and so on.

Let's see how you can integrate this into your Laravel setup.

## Updating Talwind

Firstly run from your terminal to get the latest version of tailwind.

```sh
$ npm install -D tailwindcss@latest
```

## Enabling jit mode 

As of version 2.1.0 the jit compiler is integated in Taliwind, without the need for an extra plugin. You can edit your `tailwind.config.js`  and change the mode to `jit` and you are good to go.

```js
// tailwind.config.js
module.exports = {
  mode: 'jit',
  // ...
}
```

It's important that you have the purge option correctly filled, so that **Tailwind** know
which files to take into consideration.

```js
// tailwind.config.js
module.exports = {
  mode: 'jit',
  purge: ['./resources/**/*.{js,vue,blade.php}'],
  // ...
}
```

In version **[2.2.0](https://github.com/tailwindlabs/tailwindcss/compare/v2.1.4...v2.2.0)** the context was switched from "watching" to "tracking".

From the **Tailwind** changelog:
> JIT: Use "tracking" context by default instead of "watching" context for improved reliability with most bundlers (#4514)

>Depending on which tooling you use, you may need to explicitly set TAILWIND_MODE=watch until your build runner has been updated to support PostCSS's dir-dependency message type.

So the last step would be to change the **TAILWIND_MODE** variable to "**watch**" when executing our hot or watch script. 
```json
"scripts": {
    "hot": "mix watch --hot", // [tl! remove]
    "watch": "mix watch", // [tl! remove]
    "hot": "TAILWIND_MODE=watch mix watch --hot", // [tl! add]
    "watch": "TAILWIND_MODE=watch mix watch",  // [tl! add]
},
```

## Testing the configuration
Now if you run:
```sh
$ npm run hot
```

you should see the following output in your command line:
```
> hot
> TAILWIND_MODE=watch mix watch --hot

warn - You have enabled the JIT engine which is currently in preview. [tl! highlight:0]
warn - Preview features are not covered by semver, may introduce breaking changes, and can change at any time.

info - Tailwind CSS is watching for changes... [tl! highlight:0]
info - https://tailwindcss.com/docs/just-in-time-mode#watch-mode-and-one-off-builds
```


How to install Tailwind's JIT with Laravel mix.

Install Tailwind's JIT compiler into Laravel


 In some cases you may have a 3-Way **Pivot** table where you wan't to display only the related 
 records in the **Resource Show** page. 

 Imagine having a database structure like below:
 ```
 rooms
     id - integer
     number - string

 reservation
     id - integer
     number - string

 guest
     id - integer
     name - string

 room_reservation_guest
     reservation_id - integer
     room_id - integer
     guest_id - integer
 ```

 where you want to display the guests with their room number in the reservation show page like below.

![Reservation Show Page](img/nova-reservation-show.png)

 In order to achieve this you will need to define a [custom intermediate Table Model](https://laravel.com/docs/8.x/eloquent-relationships#defining-custom-intermediate-table-models) 
 and it's `belongsTo` method.

 In our case:
 ```php
 namespace App;

use Illuminate\Database\Eloquent\Relations\Pivot;

 class RoomReservationGuest extends Pivot
 {
     public function reservation()
     {
         return $this->belongsTo(Reservation::class);
     }
     public function guest()
     {
         return $this->belongsTo(Guest::class);
     }
     public function room()
     {
         return $this->belongsTo(Room::class);
     }
 }
 ```

 Next in the `Reservation` Model define a function which will return the **intermediate table model**.

 ```php
 public function roomGuests()
 {
     return $this->hasMany(RoomReservationGuest::class);
 }
 ```

 After [create a Nova resource](./../resources/#defining-resources) for the `RoomReservationGuest` model and define it's fields.

 ```php
 public function fields(Request $request)
 {
     return [
         BelongsTo::make('Guest', 'guest', Guest::class),
         BelongsTo::make('Room', 'room', Room::class),
     ];
 }
 ```

Last define a `HasMany` field in the `Reservation` resource for the `RoomReservationGuest` relation.
 ```php
 public function fields(Request $request)
 {
     return [
         // ... 
         HasMany::make('Guests', 'roomGuests', RoomReservationGuest::class),
     ];
 }
 ```


Displaying the contents of the intermediate pivot Table Model in Laravel Nova.

3-Way Relationships with Laravel Nova


Recenly spend some hours debugging a strange behavior happening only on my local development environment for my Laravel application.
My virtual server hosted on Google Cloud seem to not be available when I was attempting to connect from my local machine, but when I attempted to connect from a remote one
everything appeared to be working fine. After quite some debugging I found it. It was the default DNS used by my local computer.

## Using custom DNS

After this I decided that I am not letting this to luck and that I am going to use the **Cloudflare** and **Google** DNS severs for now on.

So my `docker-compose.yml` file end up looking like this:

```yaml
  app:
    build: '.'
    dns:
     - 1.1.1.1 # Cloudflare
     - 8.8.8.8 # Google
    volumes:
        - ./:/var/www/app
```

And everything seem to be working fine at first, until some hours later when I discovered that the `host.docker.internal` DNS name isn't
working anymore.

## Local Docker DNS

While developing in a docker container often you may want to connect back to a service on your local machine
and for that reason docker provides the usefull special DNS name `host.docker.internal`. But when
using the `dns` section in you `docker-compose.yml` the `host.docker.internal` isn't available anymore.

For that the solution is to also add your local docker DNS ip address to you `docker-compose.yml`. So if
your subnet address is `192.168.65.0/24` then your DNS will probably be the first address `192.168.65.1`. So the final version of `docker-compose.yml` should look like this:

```yaml
  app:
    build: '.'
    dns:
     - 1.1.1.1 # Cloudflare
     - 8.8.8.8 # Google
     - 192.168.65.1 # Local Docker DNS
    volumes:
        - ./:/var/www/app
```

Afterwards `host.docker.internal` shoud work as expected.

You can find your Subnet address under: **Resources->Network** on your Mac.


How to use custom DNS in your Docker compose setup.

All Posts