m Laravel Developer for the past 2 years and all of you can agree with me that it’s a Framework for Web Artisan. From the past couple of months, I’ve been exploring Nodejs and found some very good frameworks like express.js, hapi.js, koa.js, loopback.js, restify.js, fastify.js, sails.js and few others.
So I started developing the same application prototype in almost all the framework mentioned above ( I left loopback in middle 🤫).
Working with all these frameworks makes me appreciate and admire Laravel more 🥰. With Nodejs I had to put extra efforts on scaffolding and struggling to find reliable NPM libraries rather than focusing on the application part. Besides, I had no intention to left Laravel but I kept exploring and I found AdonisJs.
Introduction: AdonisJs
AdonisJs is Nodejs framework inspired by Laravel and using similar ideas of Dependency Injection and Providers to write flexible and beautiful code. I personally believe anyone come from Laravel background and want to explore Node.js must try AdonisJs. The transition is very smooth and one can quickly get familiar with the framework and let the things done. Laravel is more like a toolkit to quickly bootstrap an application and AdonisJs provide same goodies 🎉 for Nodejs.
Highlights
Folder Structure
AdonisJs follows the same structure as Laravel, which is best suited for small to large scale applications. Like Laravel, AdonisJs has a very convenient folder structure which will keep code organized and clean. Moreover, you can always modify the structure as per your needs.
Lucid-ORM
AdonisJs has first class support for Relational Databases like Postgres and MySQL. Lucid-ORM is built on active record standards. Look at the example:
const adults = await User .query() .where('age', '>', 18) .fetch()
We can also write complex queries with the support of Transactions, DB Joins, MIgrations, Seeds, Factories, and Extensions (Postgres Only).
IOC and Service Provider
One of the major challenges is to manage dependencies in any application. Dependencies might be dependent or independent but if they are not managed properly then it may introduce unexpected bugs and behaviors. AdonisJS provide a very efficient way to manage it through IOC.
Service Providers are used to managing life-cycle of dependencies in AdonisJs. We can also extend the core feature of the Framework by extending Service Providers.
Validator and Sanitize
I always take validation very seriously because how can you even sleep at night without validating your data? Always validate your data, I repeat always. You don’t even realize how much time it’ll cost you later.
AdonisJs provides easy yet powerful validation rules to validate and sanitize data from the incoming requests both manually and at the route level.
'use strict'
class StoreUser { get rules () { return { email: 'required|email|unique:users', password: 'required' } } }
module.exports = StoreUser
Challenges
Community
Currently, AdonisJs is under active development but the community is small. Due to this, contributors and users are also less so you may find it hard to get answers on Stack Overflow.
Documentation is well written. But I still find some parts missing or need more clarifications. Apart from the documentation, tutorials are very less.
Closing Thoughts
I feel that Support from maintainers is excellent. Most of the time you can find help on Discord and Official Forum.
The community has many great plans for the upcoming version v5. Check out here.
If you have any questions or suggestion please leave the comment below and I’d love to talk!
Mass assignment: means to send an array to the model to directly create a new record in Database.
$fillable specifies which attributes in the table should be mass-assignable.
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Article extends Model
{
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $fillable = ['title', 'article_text'];
}
$guarded specifies which attributes in the table shouldn't be mass-assignable.
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Article extends Model
{
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $guarded = ['id'];
}
Properties for Tables, Keys, Increments, Pages and Dates
$table specifies a custom table.
$primaryKey specifies a custom primary key.
$incrementing specifies a non-incrementing or a non-numeric primary key.
$perPage specifies the number of items per page in paginate.
$timestamps disable created_at and updated_at columns.
CREATED_AT and UPDATED_AT specify the custom names of the columns used to store the timestamps.
$dateFormat specifies the custom format of your timestamps.
$dates converts columns to instances of Carbon.
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Article extends Model
{
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $table = 'user_articles';
protected $primaryKey = 'article_id';
public $incrementing = false;
$perPage = 5;
public $timestamps = false;
const CREATED_AT = 'creation_date';
const UPDATED_AT = 'last_update';
protected $dateFormat = 'm/d/Y H:i:s';
protected $dates = [
'created_at',
'updated_at',
'deleted_at'
];
}
Create/Update in Eloquent
"Magic" methods: FirstOrCreate() and other 2-in-1s
There are two other methods you may use to create models by mass assigning attributes: firstOrCreate and firstOrNew. The firstOrCreate method will attempt to locate a database record using the given column / value pairs. If the model can not be found in the database, a record will be inserted with the attributes from the first parameter, along with those in the optional second parameter. Laravel docs
function store(Request $request)
{
$article = Article::where('title', $request->title)->first();
if(!$article){
$article = Article::create([
'title' => $request->title,
'article_text' => $request->article_text
]);
}
// some actions with the article
$article->chapters()->create($request->chapters);
}
It can be replaced by:
function store(Request $request)
{
$article = Article::firstOrCreate(['title' => $request->title], ['article_text' => $request->article_text]);
// some actions with the article
$article->chapters()->create($request->chapters);
}
function store(Request $request)
{
$article = Article::firstOrNew(['title' => $request->title], ['article_text' => $request->article_text]);
$article->field = $value;
$article->save();
// some actions with the article
$article->chapters()->create($request->chapters);
}
updateOrCreate updates an existing model or create a new model if none exists.
<?php
namespace App\Providers;
use App\Article;
use App\Observers\UserObserver;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Article::observe(ArticleObserver::class);
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
//
}
}
Article model:
public function store(Request $request)
{
Article::create($request->all());
return redirect()->route('articles.index');
}
ArticleObserver:
public function createdArticle(Article $article)
{
info('Article is saved');
}
Every time an article is created, you will have a message in log.
[2018-09-19 20:15:26] local.INFO: Article is saved
Accessors and Mutators: Change Model Values
Accessors and mutators allow you to format Eloquent attribute values when you retrieve or set them on model instances.
Accesor -> get Attribute Mutator -> set Attribute
Create a getFullNameAttribute method on model:
public function getFullNameAttribute()
{
return $this->name . ' ' . $this->surname;
}
To access the value of the accessor, you may access the first_name attribute on a model instance:
<td>{{ $user->full_name }}</td>
public function setNameAttribute($value)
{
$this->attributes['name'] = ucfirst($value);
}
to set the first_name attribute to Taylor:
$user->first_name = 'taylor';
Database Seeds and Factories: Prepare Dummy Data
Seeders
Seeding your database with test data using seed classes. Create seeder run:
php artisan make:seeder UsersTableSeeder
add a database insert statement to the run method:
<?php
use Illuminate\Database\Seeder;
class UserTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
\App\User::create('users')->insert([
'name' => 'Admin',
'email' => 'admin@admin.com',
'password' => bcrypt('password'),
]);
}
}
Register seeder in DatabaseSeeder:
<?php
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{
/**
* Seed the application's database.
*
* @return void
*/
public function run()
{
$this->call(UsersTableSeeder::class);
}
}
Finally you run seeder :
php artisan db:seed
Model Factories
Factories generate large amounts of database records. Laravel brings by default the UserFactory with the data to declare a user: Laravel uses Faker that is a PHP library that generates fake data. Read more
then you call factory in UserTableSeeder. You can also specify the number of records:
<?php
use Illuminate\Database\Seeder;
class UserTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(App\User::class, 50)->create();
}
}
Seeds and Factories with Relationships
Define relationship:
public function up()
{
Schema::create('articles', function (Blueprint $table) {
$table->increments('id');
$table->string('title');
$table->text('article_text');
$table->unsignedInteger('user_id')->nullable();
$table->foreign('user_id')->references('id')->on('users');
$table->timestamps();
});
}
<?php
use Faker\Generator as Faker;
$factory->define(App\User::class, function (Faker $faker) {
return [
'title' => $faker->text(50),
'article_text' => $faker->text(500),
];
});
In UsertableSeeder use saveMany method:
<?php
use Illuminate\Database\Seeder;
class UserTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(App\User::class, 50)->create()->each(function($user){
$user->articles()->saveMany(factory(App\Article::class, 3)->make());
});
}
}
Check Methods/Properties in Eloquent API Docs
In the documentation you will find all the information of the eloquent API and that you can work from the models. a description, the methods and the type of value that they return, the parameters they receive and Traits available.
You can replace the orderBy() method by shortBy():
public function index()
{
$user = User::orderBy('name')->get();
return view('users.index', compact('users'))
}
You can use the collections with all() and use the sortBy method, by default sortBy orders the elements ascending:
public function index()
{
$user = User::all()->sortBy('days_active');
return view('users.index', compact('users'))
}
to order the elements in descending order you use sortByDesc():
public function index()
{
$user = User::all()->sortByDesc('days_active');
return view('users.index', compact('users'))
}
Raw Database Queries with Examples
To create a raw expression, you may use the DB::raw method:
public function index()
{
$users = User::select(DB::raw('id, name, email, created_at, DATEDIFF(updated_at, created_at) as days_Active))->get();
return view('users.index', compact('users'));
}
public function index()
{
$users = User::selectRaw('id, name, email, created_at, DATEDIFF(updated_at, created_at) as days_Active)->get();
return view('users.index', compact('users'));
}
public function index()
{
$users = User::select(DB::raw('id, name, email, created_at, DATEDIFF(updated_at, created_at) as days_Active))
->whereRaw('DATEDIFF(updated_at, created_at) > 300')
->get();
return view('users.index', compact('users'));
}
public function index()
{
$users = User::select(DB::raw('id, name, email, created_at, DATEDIFF(updated_at, created_at) as days_Active))
->orderByRaw('DATEDIFF(updated_at, created_at) desc')
->get();
return view('users.index', compact('users'));
}
Eloquent Collections and their Methods
Why You Need Collections and How to Use Them
Laravel collections are one of the most powerful provisions of the Laravel framework. They are what PHP arrays should be, but better. (scotch.io) The Eloquent collection object extends the Laravel base collection, so it naturally inherits dozens of methods used to fluently work with the underlying array of Eloquent models.
public function index()
{
$articles = Article::all();
echo 'Total articles' . $articles->count() . '<hr />';
echo 'Total word written: ' . $articles->sum('word_count') . '<hr />';
echo 'Minimun word count: ' . number_format($articles->min('word_count', 2)) . '<hr />';
echo 'Maximun word count: ' . number_format($articles->max('word_count', 2)) . '<hr />';
echo 'Average word count: ' . number_format($articles->avg('word_count', 2)) . '<hr />';
echo 'Median word count: ' . number_format($articles->median('word_count', 2)) . '<hr />';
echo 'Most often word count: ' . implode(', ' $articles->mode('word_count')) . '<hr />';
}
Calculations:
count() The count method returns the total number of items in the collection.
avg() The avg method returns the average value of a given key.
max() The max method returns the maximum value of a given key.
median() The median method returns the median value of a given key.
min() The min method returns the minimum value of a given key.
sum() The sum method returns the sum of all items in the collection.
Methods for Debugging
dd() The dd method dumps the collection´s items and ends execution of the script.
dump() The dump method dumps the collection´s items.
tap() The tap method passes the collection to the given callback, allowing you to "tap" into the collection at a specific point and do something with the items.
public function index()
{
$users = User::select(['name', 'id'])
->take(5)
->get()
->shuffle()
->chunk(3);
dd($users);
}
public function index()
{
$users = User::select(['name', 'id'])
->take(5)
->get()
->shuffle()
->tap(function ($users) {
info($users->first());
})
->chunk(3);
}
Advanced Eloquent Relationships
Polymorphic Relations Explained
A polymorphic relationship allows the target model to belong to more than one type of model using a single association.
class Photo extends model
{
protected $fillable = ['imageable_id', 'imageable_type', 'filename'];
public function imageable()
{
return $this->morphTo();
}
}
Post model:
class Post extends model
{
protected $fillable = ['title'];
public function photos()
{
return $this->morphMany('App\Photo', 'imageable');
}
}
Schema::create('imageables', function (Blueprint $table) {
$table->unsignedInteger('photo_id');
$table->foreign('photo_id')->references('id')->on('photos');
$table->unsignedInteger('imageable_id');
$table->string('imageable_type');
});
Photo model:
class Photo extends model
{
protected $fillable = ['filename'];
public function products()
{
return $this->morphedByMany('App\Product', 'imageable');
}
public function posts()
{
return $this->morphedByMany('App\Post', 'imageable');
}
}
Product model:
class Product extends model
{
protected $fillable = ['title'];
public function photos()
{
return $this->morphedByMany('App\Photo', 'imageable');
}
}
Post model:
class Post extends model
{
protected $fillable = ['title'];
public function photos()
{
return $this->morphedByMany('App\Photo', 'imageable');
}
}
Imageable model:
class Imageable extends model
{
public $timestamps = false;
protected $fillable = ['photo_id', 'imageable_id', 'iamgeable_type'];
}
class User extends Authenticatable
{
use Notifiable;
protected $fillable = [
'name','email','password', 'role_id',
];
protected $hidden = [
'password','remember_token',
];
public function role()
{
return $this->belongsTo(Role::class);
}
public function posts()
{
return $this->hasMany(Post::class);
}
}
Role model:
class Role extends model
{
protected $fillable = ['name'];
public function users()
{
return $this->hasMany(User::class);
}
public function posts()
{
return $this->hasManyThrough(Post::class, User::class);
}
}
Post model:
class Post extends model
{
protected $fillable = ['user_id', 'title', 'post_text'];
public function user()
{
return $this->belongsTo(User::class);
}
}
class Book extends Model
{
protexted $fillable = ['author_id', 'title'];
public function author()
{
return $this->belongsTo(Author::class);
}
public function ratings()
{
return $this->hasMany(Rating::class);
}
}
public function index()
{
Author::whereHas('books', function($query){
$query->where('title', 'like', '%b%');
})->get()->dd();
return view('books.index', compact('books'));
}
Eloquent Performance
Laravel Debugbar: How to Measure Performance
Installation:
composer require barryvdh/laravel-debugbar --dev
Example:
public function index()
{
$books = Book::with('author')
->where('title', 'like', '%a%')
->take(50)
->get();
return view('books.index', compact('books'));
}
Queries output in debugbar:
select * from `books` where `title` like `%a%` limit 50 (1.46ms)
public function index()
{
$authors = Author::with('books')
->take(20)
->get();
return view(books.index, compact('authors'));
}
public function getBooksCountAttribute()
{
return $this->books->count();
}
Laravel Debugbar output:
Queries 21 - 1.88s
You can use Cache::remember to caching the model for fifteen minutes. You can cache properties and associations on your models that are automatically updated (and the cache invalidated) when the model (or associated model) is updated.
Example:
public function index()
{
$authors = Author->take(20)->get();
return view(books.index, compact('authors'));
}
public function getBooksCountAttribute()
{
return Cache::remember('author-books-' . $this->id, 15, function(){
return $this->books->count();
});
}
Useful Packages to Extend Eloquent
spatie/laravel-medialibrary: Associate files with Eloquent models
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Spatie\MediaLibrary\HasMedia\HasMediaTrait;
use Spatie\MediaLibrary\HasMedia\HasMedia;
use Spatie\MediaLibrary\Models\Media;
class Book extends Model implements HasMedia
{
use HasMediaTrait;
protected $fillable = ['author_id', 'title'];
public function author()
{
return $this->belongsTo(Author::class);
}
public function registerMediaConversions(Media $media = null)
{
$this->addMediaConversion('thumb')
->width(100)
->height(100);
}
}
BookController:
<?php
namespace App\Http\Controllers;
use App\Book;
use App\Author;
use Illuminate\Http\Request;
class BookController extends Controller
{
public function index()
{
$books = Book::with('author')->get();
return view('books.index', compact('books'));
}
public function create()
{
$authors = Author::all();
return view('books.create', compact('authors'));
}
public function store(Request $request)
{
$book = Book::create($request->all());
if ($request->hasFile('cover_image')) {
$book->addMediaFromRequest('cover_image')->toMediaCollection('cover_images');
}
return redirect()->route('books.index');
}
}
<?php
namespace App;
use Dimsav\Translatable\Translatable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
class Article extends Model
{
use SoftDeletes;
use Translatable;
protected $fillable = ['title', 'article_text'];
public $translatedAttributes = ['title', 'article_text'];
}
ArticleTranslation model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class ArticleTranslation extends Model
{
public $timestamps = false;
protected $fillable = ['title', 'article_text'];
}
/*
|--------------------------------------------------------------------------
| Application Locale Configuration
|--------------------------------------------------------------------------
|
| The application locale determines the default locale that will be used
| by the translation service provider. You are free to set this value
| to any of the locales which will be supported by the application.
|
*/
'locale' => 'en',
to translate any field we use the translate method:
