Forem: Titas Gailius

Roll your own Request object in Laravel

Titas Gailius — Thu, 31 Dec 2020 12:50:00 +0000

There are multiple ways to extend or modify the Request object in Laravel. I'd like to show you a method, which in my opinion is the cleanest one.

Macro

You may already know about the macro method. It's the most obvious way to introduce new methods to the Request object but it has some downsides.

Request::macro('project', function () {
    return $this->user();
});

This solution is simple but it has some flaws:

• You cannot override or change existing methods.
• It's not obvious where these new methods are coming from.
• No IDE autocompletion.

Custom Request Object

I like creating my own Request object.

<?php

namespace App\Http;

use Illuminate\Http\Request as LaravelRequest;

class Request extends LaravelRequest
{
    /**
     * Get the team making the request.
     *
     * @param  string|null  $guard
     * @return mixed
     */
    public function team($guard = null)
    {
        return $this->user($guard);
    }
}

It's simple, clean and straightforward. Much better than introducing new methods via "macros".

Now, we need to instruct Laravel to use this new custom class as a base.

Simply override the handle method in our App\Http\Kernel class to use your custom Request object.

<?php

namespace App\Http;

use App\Http\Request;
use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel
{
    // ...

    /**
     * Handle an incoming HTTP request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function handle($request)
    {
        return parent::handle(
            Request::createFrom($request)
        );
    }
}

... and finally, alias your new App\Http\Request class so the container always returns the same instance.

$this->app->alias('request', Request::class);

Happy Coding!

Multi-stage Docker Builds for Laravel

Titas Gailius — Mon, 07 Sep 2020 15:19:17 +0000

Most applications have a build step to download all the dependencies and/or compile your frontend assets.

Usually, it takes most of the deployment time.

Not to mention that the final image may be bigger because of the unnecessary dependencies that were used to download dependencies and compile the frontend assets.

Docker multi-stage builds

One of the easiest ways to make your deployments faster and images slimmer is to use multi-stage docker builds.

Docker caches a specific stage and only re-runs it if any of the dependent files have been changed.

Composer Step

Use Composer 2.0 image.
Copy files required for "composer install".
Run "composer install".
Copy the rest of the files.
Run "composer dump-autoload".

#
# PHP Dependencies
#
FROM composer:2.0 as vendor

WORKDIR /app

COPY database/ database/
COPY composer.json composer.json
COPY composer.lock composer.lock

RUN composer install \
    --no-interaction \
    --no-plugins \
    --no-scripts \
    --no-dev \
    --prefer-dist

COPY . .
RUN composer dump-autoload

NPM Step

Use NodeJS image.
Cop files required for the "npm install".
Run "npm install".
Copy files required to build your frontend assets.
Build your frontend assets.

#
# Frontend
#
FROM node:14.9 as frontend

WORKDIR /app

COPY artisan package.json webpack.mix.js yarn.lock tailwind.js ./

RUN npm install

COPY resources/js ./resources/js
COPY resources/sass ./resources/sass

RUN npm run production

Application Step

Use your desired image.
Copy built files from the previous stages.
Enjoy fast deployments.

#
# Application
#
FROM php:7.4-fpm

WORKDIR /app

# Install PHP dependencies
RUN apt-get update -y && apt-get install -y libxml2-dev
RUN docker-php-ext-install pdo pdo_mysql mbstring opcache tokenizer xml ctype json bcmath pcntl

# Copy Frontend build
COPY --from=frontend /app/node_modules/ ./node_modules/
COPY --from=frontend /app/public/js/ ./public/js/
COPY --from=frontend /app/public/css/ ./public/css/
COPY --from=frontend /app/public/mix-manifest.json ./public/mix-manifest.json

# Copy Composer dependencies
COPY --from=vendor /app/vendor/ ./vendor/
COPY . .

RUN php artisan config:cache
RUN php artisan route:cache

You may find the full Dockerfile used in this article here.

Enjoy!

Laravel Moonlight

Titas Gailius — Mon, 13 Apr 2020 11:48:07 +0000

Laravel Moonlight is a carefully crafted Laravel preset.

The goal of this preset is to provide an elegant scaffolding for your next single-page application.

Stack

VueJS
InertiaJS
TailwindCSS
Ziggy (Use named routes from your JS)

Usage

You may generate a basic scaffolding running this artisan command:

php artisan ui moonlight

Laravel Moonlight comes with a full-featured authentication scaffolding. You may include the authentication scaffolding by adding the --auth option:

php artisan ui moonlight --auth

Authentication scaffolding comes with these views:

Login
Register
Resend verification email
Reset password
Confirm new password (after password reset)
Confirm password (just like when GitHub asks to confirm your password for certain actions)

Routes

You may use Laravel named routes straight from your Vue components:

<a :href="$route('login')">Login</a>

The $route helper is powered by Ziggy.

Authenticated User

Every page has access to the authenticated user through a prop:

export default {
    props: {
        user: Object,
    }
}

Alternatively, you may access the authenticated user through a global variable: $page.user.

<h1>Hello, {{ $page.user.name }}</h1>

Validation Errors

Just like the authenticated user, you may access the validation errors through a prop:

export default {
    props: {
        errors: Object,
    }
}

Alternatively, you may access the validation errors through a global variable: $page.errors.

<span class="form-error">{{ $page.errors.email[0] }}</span>

Screenshots

Lastly, here are a few screenshots with the views that are included with this preset. You may find more on the GitHub repo.

Feel free to check out full documentation at https://github.com/TitasGailius/laravel-moonlight

Feedback is more than welcome!

Introducing Terminal

Titas Gailius — Sun, 22 Mar 2020 12:25:29 +0000

Terminal

An elegant wrapper around Symfony's Process component.

Why?

I've been developing hosting related services for almost 4 years now.

To complete various tasks, I have to write PHP code that executes bash scripts almost on a daily basis. Let's say you want to set up automatic updates for WordPress or put your site to the maintenance mode.

That's where Terminal comes in handy.

Example

To activate "maintenance mode" in WordPress, you might need to execute this wp-cli command:

$ wp maintenance-mode activate
Enabling Maintenance mode...
Success: Activated Maintenance mode.

Now, with the Terminal, you can do this straight from your PHP script:

Terminal::run('wp maintenance-mode activate');

You can even setup timeout, retries, change the current working directory and much more:

Terminal::in(storage_path('sites/123'))
    ->timeout(120)
    ->retries(3)
    ->run('wp maintenance-mode activate');

Extending

Another cool feature of the Terminal is that you can easily define your custom commands.

Terminal::extend('maintenanceOn', function ($terminal) {
    return $terminal->run('wp maintenance-mode activate');
});

Terminal::maintenanceOn();

Testing

It gets even better.
Terminal comes with a bunch of beautiful testing utilities that help you write simple and expressive tests for your application.

Terminal::fake();

Terminal::run($command = 'wp maintenance-mode activate');

Terminal::assertExecuted($command);

Feel free to check out full documentation at https://github.com/TitasGailius/terminal

Feedback is more than welcome!

Building HTTP clients with Guzzle

Titas Gailius — Tue, 04 Sep 2018 14:34:19 +0000

Whenever you integrate some external service that exposes an HTTP API you'll end up writting a client to interact with that service.

There're many different ways to build these http clients although the 3 most common approaches I encountered are listed below.

1. Creating a client class that extends guzzle.

2. Creating a client class that handles all the logic and calls guzzle.

3. Creating a client class where all the logic is handled by guzzle middleware.

Which one do you prefer? Do you have any alternatives? Discuss.

Forem: Titas Gailius

Roll your own Request object in Laravel

Macro

Custom Request Object

Happy Coding!

Multi-stage Docker Builds for Laravel

Docker multi-stage builds

Composer Step

NPM Step

Application Step

Laravel Moonlight

Stack

Usage

Routes

Authenticated User

Validation Errors

Screenshots

Introducing Terminal

Terminal

Why?

Example

More

Extending

Testing

Building HTTP clients with Guzzle

Which one do you prefer? Do you have any alternatives? Discuss.