Laravel Macroable Models Package

 

Javier Ugarte released a package called Laravel Macroable Models for adding methods to Laravel models on the fly:

The package offers developers an easy way of programmatically adding methods to Laravel Eloquent models. Behind the scenes, it makes use of Laravel’s macroable trait.

The idea of macorable models has controversy around it, but the package author describes his particular use-case and solution in his writeup about the package. As always, be sure to explore your use-case, and in general macroable models won’t be necessary for most use-cases.

With that said, let’s check out what this package provides:

You can define a macro for a model through a service provider boot() method. The package keeps track of macros for each model.

// app/Providers/AppServiceProvider.php

use \Javoscript\MacroableModels\Facades\MacroableModels;

use \App\User;

public function boot()

{

   MacroableModels::addMacro(User::class, 'sayHi', function() {

        return "Hello, {$this->name}!";

    });

}

\App\User::first()->sayHi();

As you can see in the example above, this package takes care of context binding so you can use $this inside macro functions.

Here are a few more functions the package provides:

MacroableModels::modelsThatImplement('sayHi');

/* [

    "App\User",

] */

// Return all macros for a model

MacroableModels::macrosForModel(\App\User::class);

// Get all registered macros

MacroableModels::getAllMacros();

Learn More

I want to reiterate that this package has a narrow, unique use-case. Typically, you wouldn’t need macros to define model methods on-the-fly. I’d recommend reading the author’s writeup about this package and his inspiration behind it.

You can learn more about this package, get full installation instructions, and view the source code on GitHub.

Read More

Extract Untranslated Strings from Laravel Projects

 

Localizator is a small tool for Laravel that gives you the ability to extract untranslated strings from project files. It works using the artisan command line and the provided localize command:

php artisan localize de,fr

The above command will create a de.json and fr.json file in the resources/lang folder or add missing keys if these files already exist.

You can also use the configuration value in app.locale by running the command without arguments:

# Use the `config('app.locale')` value

php artisan localize

The package also provides configurable values to suit your project’s needs, along with sensible defaults:

return [

    /**

     * Search criteria for files.

     */

    'search' => [

        /**

         * Directories which should be looked inside.

         */

        'dirs' => ['resources/views'],

        /**

         * Patterns by which files should be queried.

         * The values can be a regular expresion, glob, or just a string.

         */

        'patterns' => ['*.php'],

        /**

         * Functions that the strings will be extracted from.

         * Add here any custom defined functions.

         * NOTE: The translation string should always be the first argument.

         */

        'functions' => ['__', 'trans', '@lang']

    ],

    /**

     * Should the localize command sort extracted strings alphabetically?

     */

    'sort' => true,

];

You can learn more about this package, get full installation instructions, and view the source code on GitHub.

Read More

Bandwagon is a Social Proof Package for Laravel

 

Laravel Bandwagon is a package to help promote social proof and legitimacy within your application. You can let users of your application know when others’ share, purchase, subscribe, or donate, for example:

Using blade and Vue, here’s how easy it is to feed data into the social proof component, which is then displayed in the user’s browser via polling:

use Bndwgn\Bandwagon\Bandwagon;

public function purchase(Request $request, Product $product)

{

    $user = Auth::user();

    // ... logic to charge a customer

    Bandwagon::createEvent(

        "Someone from ${$user->state}",

        "Purchased the ${$product->displayName} plan",

        $request->ip()

    );

}

In your blade template (i.e., on your product page), you render the widget by using the provided blade component:

<x-bandwagon-renderer />

The package allows you to configure things like poll increments (how often to check for new events), how long to display events, and the age of valid events.

Bandwagon’s documentation is available on www.laravelbandwagon.com, and you can learn more about this package’s source code on GitHub.

Read More

Snappy Image Wrapper for Laravel

 

Snappy is a PHP library allowing thumbnails, snapshots, and PDF generation from a URL or HTML page. Barry vd. Heuvel is the author of a Laravel Snappy (which has been around since Laravel 5), making it even easier to integrate with Laravel:

// Generate a PDF From a view

$pdf = PDF::loadView('pdf.invoice', $data);

$pdf->download('invoice.pdf');

// Generate a PDF from a URL

PDF::loadFile('https://www.github.com')

     ->inline('github.pdf');

// Change the orientation and paper size

PDF::loadHtml($html)

     ->setPaper('a4')

     ->setOrientation('landscape')

     ->setOption('margin-bottom', 0)

     ->save('myfile.pdf');

Along with some nifty convenience methods, Snappy for Laravel has testing features to help you assert things that Snappy generates:

PDF::fake();

// Perform order shipping...

PDF::assertViewIs('view-pdf-order-shipping');

PDF::assertSee('Name');

Snappy requires the wkhtmltopdf (available on Windows, Mac, and Linux), which is a command-line tool to render HTML into PDF and various image formats. Installation instructions are available in the readme so you can ensure wkhtmltopdf is installed and the path configured properly.

Read More

Organize Laravel Applications With Actions

 

The Laravel actions package provides a new way to organize your Laravel applications’ logic by focusing on actions. Using this technique, you can execute the same class as a controller, a command, a job, and a listener.

In v2, the package no longer extends an Action class but instead uses traits to provide helper methods and detect which context to execute a class.

Here’s a simple example of an action class that we can use as a controller, an object, a job, a listener, etc.:

namespace App\Authentication\Actions;

use Lorisleiva\Actions\Concerns\AsAction;

class UpdateUserPassword

{

    use AsAction;

    public function handle(User $user, string $newPassword)

    {

        $user->password = Hash::make($newPassword);

        $user->save();

    }

}

And here are the various ways you can run this class:

// Equivalent to "app(UpdateUserPassword::class)".

UpdateUserPassword::make();

// Equivalent to "UpdateUserPassword::make()->handle($user, 'secret')".

UpdateUserPassword::run($user, 'secret');

// As a controller defined in routes

Route::put(

    'auth/password',

    UpdateUserPassword::class

)->middleware('auth');

You can even define controller validation within the UpdateUserPassword action:

public function rules()

{

    return [

        'current_password' => ['required'],

        'password' => ['required', 'confirmed'],

    ];

}

You can even run this class as a command. Check out the Basic usage documentation for details on defining actions capable of running as a command.

Read More

Squire: Static Eloquent Model Library

 

Squire is a library of prebuilt static Eloquent models for common fixture data. It provides information about countries, currencies, airports, and more to your Laravel app, without the use of a third-party API.

Setup is simple – just install the model packages that you need in your app, and you’re ready to go. Squire comes out of the box with queryable Eloquent models, validation rules, and full localization support.

Squire is built upon the principles demonstrated in Caleb Porzio’s Sushi package: all models are served by their own SQLite databases, and cached.

Building a Country Select Input

We’re going to create a country select input using data from Squire. Let’s install the Squire\Models\Country model in English:

composer require squirephp/countries-en

Tip: all Squire models are translatable. Squire can automatically serve the correct data based on your user’s locale. To try it out, also install the squirephp/countries-fr package, and notice how French users will be served in the correct language.

To keep things simple, use Blade to query the Country model and render our select options:

<select name="country">

    @foreach (Squire\Models\Country::orderBy('name')->get() as $country)

        <option value="{{ $country->id }}">{{ $country->name }} {{ $country->flag }}</option>

    @endforeach

</select>

Validate the input to ensure that a valid country has been selected in a controller:

use Squire\Rules\Country;

$request->validate([

    'country' => ['required', 'string', new Country],

]);

You’re able to use conventional Eloquent relationships between Squire and non-Squire models. Let’s set up a country relationship for the country_id column on the App\Models\User model:

use Squire\Models\Country;

public function country()

{

    return $this->belongsTo(Country::class);

}

Save the selected country to $user in your controller:

$user->country()->associate($request->country);

$user->save();

Rounding Off

Squire has the capability to replace many third-party APIs in your Laravel app, cutting costs and improving performance.

The ecosystem is constantly expanding as new models and translations are submitted and published by the community. If you see anything missing, feel free to open a feature discussion or pull request in the repository, or release your own Squire package.

If you have any questions, feel free to tweet me @danjharrin and I’ll do my best to respond. If you love Squire, sponsoring me on GitHub ensures I can dedicate time to maintaining and improving the package.

Read More

OpenAPI Initializer

 

OpenAPI Initializer is a Laravel package that provides a straightforward command to scaffold an OpenAPI spec file.

Once you install the package, you can run the artisan command to walk you through various questions to make the OpenAPI specification.

You start by running the command:

php artisan openapi:create

Then the plugin will walk you through a bunch of questions to construct the specification file:

Once you walk through the questions, OpenAPI Initializer will generate an openapi.yml specification file that will look similar to the following:

openapi: 3.0.3

info:

    title: ''

    version: 0.1.0

    description: 'Test API'

    contact: { name: 'Laravel News', email: user@example.com, url: null }

servers:

    - { url: 'http://openapi-demo.test', description: 'Local url for testing' }

tags: null

paths: null

components:

    schemas: null

    responses: null

    headers: null

    parameters: null

    links: null

    examples: null

You can learn more about this package, get full installation instructions, and view the source code on GitHub. If you’d like the know more about OpenAPI, I suggest an OpenAPI 3.0 Tutorial and the OpenAPI Specification (3.0.3) document.

Read More

Simplifying Service Providers With Laravel Package Tools

 

Laravel Package Tools is a package by Spatie that provides an opinionated base service provider you can use to streamline the registration of your package’s config files, migrations, commands, and more.

Here’s how to simplify service providers in @laravelphp packageshttps://t.co/qKmIO7nUJY

Spoiler: I released a package for that https://t.co/URH2udPbiJ#php #laravel pic.twitter.com/tWCGuE8HG8

— Freek Van der Herten (@freekmurze) January 25, 2021

I think you’ll agree that this package can streamline common use-cases found in package service providers:

use Spatie\LaravelPackageTools\PackageServiceProvider;

use Spatie\LaravelPackageTools\Package;

class YourPackageServiceProvider extends PackageServiceProvider

{

    public function configurePackage(Package $package) : void

    {

        $package

            ->name('your-package-name')

            ->hasConfigFile()

            ->hasViews()

            ->hasTranslations()

            ->hasMigration('create_package_tables')

            ->hasCommand(YourCoolPackageCommand::class);

    }

}

Spatie also provides a skeleton Laravel package you can use as a template for your next package project. The Laravel skeleton uses the package tools service provider out of the box.

Read More

Laravel Console Wizard

 

Laravel Console WIzzard is a package for creating multi-step wizards with complex input inside the console. Its primary purpose is to collect data for file generators—here’s an example from the project’s readme:

namespace App\Console\Commands;

use Shomisha\LaravelConsoleWizard\Command\Wizard;

use Shomisha\LaravelConsoleWizard\Steps\ChoiceStep;

use Shomisha\LaravelConsoleWizard\Steps\TextStep;

class IntroductionWizard extends Wizard

{

    protected $signature = "wizard:introduction";

    protected $description = 'Introduction wizard.';

    public function getSteps(): array

    {

        return [

            'name'   => new TextStep("What's your name?"),

            'age'    => new TextStep("How old are you?"),

            'gender' => new ChoiceStep("Your gender?", ["Male", "Female"]),

        ];

    }

    public function completed()

    {

        $this->line(sprintf(

            "This is %s and %s is %s years old.",

            $this->answers->get('name'),

            ($this->answers->get('gender') === 'Male') ? 'he' : 'she',

            $this->answers->get('age')

        ));

    }

}

This package works by defining a set of steps and then once completed, you can process data for output, generate files, or perform whatever you need to with the data.

• TextStep – expects a text input answer (i.e., name)
• MultipleAnswerTextStep – similar to TextStep, except it takes multiple answers and returns them in an array
• ChoiceStep – this allows a user to pick one answer from multiple choices
• MultipleChoiceStep – similar to ChoiceStep, but allows the user to pick multiple choices and returns the values as an array
• UniqueMultipleChoiceStep – just like MultipleChoiceStep, but does not allow a user to select a single choice more than once
• ConfirmStep – the user confirms yes or no, and this step returns a Boolean.

Read More

Use Basecamp’s Hotwire in Laravel

 

Turbo Laravel is a package that gives you a set of conventions to get the most out of Hotwire in Laravel. Turbo is inspired by the turbo-rails gem, giving Laravel developers a similar experience as those developing with Hotwire in the Ruby world.

Hotwire is an open-source tool built by Basecamp (it powers the HEY email service), which provides an alternative approach to building modern web applications without using much JavaScript and sending HTML instead of JSON over the wire.

Turbo Laravel supports Turbo features outlined by the Hotwire documentation. For those new to Hotwire, here are the descriptions of each technique from the website:

• Turbo Drive – accelerates links and form submissions by negating the need for full page reloads.
• Turbo Frames – decompose pages into independent contexts, which scope navigation and can be lazily loaded.
• Turbo Streams – deliver page changes over WebSocket, SSE or in response to form submissions using just HTML and a set of CRUD-like actions.
• Turbo Native – lets your majestic monolith form the center of your native iOS and Android apps, with seamless transitions between the web and native sections.

Along with this package, there is a turbo-laravel-test-helpers companion package that adds a couple of macros and assertion helpers to test your applications built with Turbo Laravel:

/** @test */

public function turbo_stream_test()

{

    $response = $this->turbo()->post('my-route');

    $response->assertTurboStream();

    // Checks if one of the Turbo Stream responses matches these criteria.

    $response->assertHasTurboStream($target = 'users', $action = 'append');

    // Checks if there is no Turbo Stream tag for the criteria.

    $response->assertDoesntHaveTurboStream($target = 'empty_users', $action = 'remove');

}

Read More

CLI to Check For PHP Security Vulnerabilities

 

Enlightn Security Checker (from the folks behind Enlightn) is a command-line tool that checks if your application uses dependencies with known security vulnerabilities.

You can install it globally via composer to start checking projects:

composer global require enlightn/security-checker

Using the security-checker CLI, you provide a path to your project’s composer.lock file to get a report of any vulnerabilities:

⇒ security-checker security:check /path/to/composer.lock

{

    "laravel\/framework": {

        "version": "5.7.29",

        "time": "2020-04-14T14:16:19+00:00",

        "advisories": [

            {

                "title": "RCE vulnerability in \"cookie\" session driver",

                "link": "https:\/\/blog.laravel.com\/laravel-cookie-security-releases",

                "cve": null

            }

        ]

    },

    "robrichards\/xmlseclibs": {

        "version": "2.1.1",

        "time": "2019-11-05T11:51:00+00:00",

        "advisories": [

            {

                "title": "Filter input to avoid XPath injection",

                "link": "https:\/\/github.com\/robrichards\/xmlseclibs\/commit\/649032643f7aac493e91ca318da0339aec72aa4a",

                "cve": null

            }

        ]

    }

}

You can programmatically get a report with the following PHP code:

use Enlightn\SecurityChecker\SecurityChecker;

$result = (new SecurityChecker)->check('/path/to/composer.lock');

/*

{

  "laravel/framework": {

    "version": "8.22.0",

    "time": "2021-01-13T13:37:56+00:00",

    "advisories": [{

      "title": "Unexpected bindings in QueryBuilder",

      "link": "https://blog.laravel.com/security-laravel-62011-7302-8221-released",

      "cve": null

    }]

  }

}

*/

The Enlightn Security Checker uses the security advisories database to reference known security vulnerabilities in PHP projects and libraries. You can learn more about this package and view the source code on GitHub.

Read More