Aire Form Builder Package for Laravel

 

Aire is a Laravel form builder package by Chris Morrell with features like data binding and an expressive syntax:

Aire is a modern Laravel form builder (demo) with a focus on the same expressive and beautiful code you expect from the Laravel ecosystem.

Here’s a basic demo from the project’s readme:

{{ Aire::open()->route('users.update') }}

{{ Aire::bind($user) }}

<div class="flex flex-col md:flex-row">

  {{ Aire::input('given_name', 'First/Given Name')
    ->id('given_name')
    ->autoComplete('off')
    ->groupClass('flex-1 mr-2') }}

  {{ Aire::input('family_name', 'Last/Family Name')
    ->id('family_name')
    ->autoComplete('off')
    ->groupClass('flex-1') }}

</div>

{{ Aire::email('email', 'Email Address') }}

{{ Aire::submit('Update User') }}

{{ Aire::close() }}

I like data binding features that typically come with form builder libraries which make it simple to map a model to form inputs. The data binding also takes care of populating form inputs with old() data when validation errors occur.

The Aire package includes Eloquent model binding along with the ability to bind custom array/object data:

// Bind Eloquent models
Aire::bind(User::find(1));

// Bind an array
Aire::bind(['given_name' => 'Chris']);

// Bind any object
Aire::bind((object) ['given_name' => 'Chris']);

If data binding was not enough, this package also automatically picks up any errors and applies error classes and shows error messages with the associated input. Also, you have access to a summary of error messages with the following methods:

// Print "There are X errors on this page that you must fix before continuing."
{{ Aire::summary() }}

// Also include an itemized list of errors
{{ Aire::summary()->verbose() }}

To get started with the Aire Form Builder package, head over to the Documentation & Demos. You can view the source code on GitHub at glhd/aire.

Read More

Add Social Reactions to Model with Laravel Love

Add Social Reactions to Model with Laravel Love

We covered Laravel Love on Laravel News about a year ago, and a lot has changed—Laravel Love has been reimagined and now has more advanced features that we thought it worth looking at the package again:

Laravel Love is an emotional part of the application. It let people express how they feel about the content. Make any model reactable in minutes!

There are many different implementations of ways to react to content in modern applications:

• Github Reactions
• Facebook Reactions
• YouTube Likes
• Slack Reactions
• Reddit Votes
• Medium Claps
• Disqus Reactions

This package has all of the above use-cases in mind, and since v7 now includes a weighted reaction system as well.

The main focus of the updated package is around two models: the Reacterable model and the Reactable model. The Reacterable model is a model which can act as a Reacter, such as a User, Person, or Organization. The Reactable model is a model that can act as a Reactant such as a Comment, Post, or User.

Here’s an example from the documentation of how a Reacterable model might look:

<?php

namespace App;

use Cog\Contracts\Love\Reacterable\Models\Reacterable as ReacterableContract;
use Cog\Laravel\Love\Reacterable\Models\Traits\Reacterable;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable implements ReacterableContract
{
    use Reacterable;
}

And here’s a code example of actually reacting to a model:

$reacterFacade = $user->viaLoveReacter();
$reacterFacade->reactTo($comment, 'Like');

// Example using weight
$reacter->reactTo($reactant, 'Like', 4.0);

// Remove reaction
$reacterFacade->unreactTo($comment, 'Like');

// Has the model reacted?
$reacterFacade->hasReactedTo($comment);

// Get reactions
$reactions = $reacterFacade->getReactions();

Laravel Love v8 features extensive documentation that you can see at laravel-love.readme.io/docs. You can view the source code on GitHub at cybercog/laravel-love.

Read More

PHP Array Redactor

 

The Array Redactor package is a PHP library by Mark Townsend to redact array values by their keys. I think the easiest way to understand how this package works is with a code example from the readme:

use Mtownsend\ArrayRedactor\ArrayRedactor;

// An example array, maybe a request being made to/from an API application you wish to log in your database
$login = [
    'email' => 'john_doe@domain.com',
    'password' => 'secret123',
    'data' => [
        'session_id' => 'z481jf0an4kasnc8a84aj831'
    ],
];

$redactor = (new ArrayRedactor($login, ['password', 'session_id']))->redact();

// $redactor will return:
[
    'email' => 'john_doe@domain.com',
    'password' => '[REDACTED]',
    'data' => [
        'session_id' => '[REDACTED]'
    ],
];

The package also allows you to pass a valid JSON string instead of an array of content:

$json = json_encode([
    'email' => 'john_doe@domain.com',
    'password' => 'secret123',
    'data' => [
        'session_id' => 'z481jf0an4kasnc8a84aj831'
    ],
]);

$redactor = (new ArrayRedactor($json, ['password', 'session_id']))->redact();

The redactor call returns an array version of the JSON string just like the previous example.

This package is useful for any PHP project, and additionally provides a service provider you may use with Lumen and Laravel. Further, if you want to use the project’s Laravel Facade, you need to register the alias in your config/app.php file:

<?php

return [
    // ...
    'aliases' => [
        // ...
        'ArrayRedactor' => Mtownsend\ArrayRedactor\Facades\ArrayRedactor::class,
    ],
];

When then enables the following within a Laravel project:

use ArrayRedactor;

// Laravel prefills our keys() and ink() methods for us from the config file
ArrayRedactor::content($array)->redact();

When using this project with the Laravel Facade, you need to configure the keys to redact, which can be found in the config/arrayredactor.php file after you publish the vendor config.

Why might you want to use this package? The author provides an explanation in the package’s readme:

Have you ever built or interacted with an api and needed to log all outgoing and incoming calls? Chances are that somewhere in that process is an authentication, either by an app or on behalf of a user. Logs are useful for debugging, but storing sensitive information such as passwords or api keys is not something you want to have in your logs for anyone to see. The usage goes beyond just this example, but that is what prompted me to create the ArrayRedactor package.

You can learn more about this package, get full installation instructions, and view the source code on GitHub at mtownsend5512/array-redactor.

Read More

Advanced State Support for Laravel Models

 

Laravel Model States is a Spatie package by Brent Roose that adds advanced state support to Laravel models.

For full details on this package, read the official documentation; however, we will provide a few examples from the readme here to give you an idea what this package provides:

Here’s an example from the readme of a Payment model and how you’d define a state for this model using this package:

use Spatie\ModelStates\HasStates;

/**
 * @property \App\States\PaymentState state
 */
class Payment extends Model
{
    use HasStates;

    protected function registerStates(): void
    {
        $this
            ->addState('state', PaymentState::class)
            ->allowTransition(Pending::class, Paid::class)
            ->allowTransition(Pending::class, Failed::class, PendingToFailed::class);
    }
}

The PaymentState in the example above is defined as follows:

// The abstract PaymentState class
use Spatie\ModelStates\State;

abstract class PaymentState extends State
{
    abstract public function color(): string;
}

// The "paid" state for the Payment model
class Paid extends PaymentState
{
    public function color(): string
    {
        return 'green';
    }
}

And finally here’s an example of transitioning the state:

$payment = Payment::find(1);

$payment->state->transitionTo(Paid::class);

echo $payment->state->color();

According to the package readme, it combines the concepts from the state pattern and state machines—you should be familiar with these concepts before using this package. The video State Pattern – Design Patterns (ep 17) is an excellent resource for understanding the basics of state machines.

To learn more about this package, view the source code on GitHub at spatie/laravel-model-states and read the model states documenation.

This package was submitted to our Laravel News Links section. This section is a place the community can post packages and tutorials around the Laravel ecosystem. Follow along on Twitter @LaravelLinks

Read More