Vous aimez Rails et Laravel ? Vous aimerez aussi Adonis.js
Tags: french, javascript, rails, laravel
Published: 2021-06-11 01:02:10

---
title: Vous aimez Rails et Laravel ? Vous aimerez aussi Adonis.js
description: 
published: true
tags: french, javascript, rails, laravel
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2r7pwf06szmde50ryv93.png
---
Si vous désirez plus de contenu francophone comme celui-ci, cliquer <strong>Follow<string> ou <a href="https://twitter.com/EricLeCodeur" class="twitter-follow-button">suivez-moi sur Twitter</a>
<hr>

<h2>Adonis = Framework MVC pour Node.js</h2>
Je développe souvent avec Rails et Laravel. J'adore ces framework. Ils sont puissants, stables, rapides et faciles à utiliser. Lorsque vous vous habituez à développer avec un bon framework MVC, il est difficile de revenir en arrière.

Plus tôt cette année, j'ai eu le mandat de développer une application frontend en javascript. Pour accompagner cette application je me suis dit pourquoi ne pas utiliser un backend en javascript aussi. Le but était d'avoir toute mon stack en javascript.

Sur papier, cela semblait facile mais en réalité la tâche était beaucoup plus compliquée que prévu. Je n'ai pas trouvé de framework javascript qui, à mon avis, soit aussi bon que Laravel et Rails. Bon dans le sens de l'efficacité du développement, c'est-à-dire puissant, rapide mais très facile et agréable à travailler.

J'ai essayé 3 frameworks différents et aucun ne correspondait à ce que je cherchais, j'ai donc décidé pour ce projet d'utiliser un backend Laravel.

Récemment, je suis tombé sur un framework qui existait depuis un certain temps, mais pour une raison que je ne connaissais pas, il était passé sous mon radar. Ce framework est Adonis.js

Qu'est-ce qu'Adonis ? En résumé, il s'agit de la version Node.js de Laravel. C'est un framework qui contraste avec les autres frameworks Node.js. Comme Laravel, Adonis a pour mission le bonheur du développeur et aussi pour mandat de fournir tous les outils nécessaires pour mener à bien un projet de A à Z.

Je n'ai pas encore fait de vrai projet en production mais j'ai quand même eu la chance de faire quelques petits projets pour le plaisir et je dois dire que je suis agréablement surpris de voir à quel point Adonis est naturel et facile à utiliser.

Étant un framework MVC tout comme Laravel, la courbe d'apprentissage est beaucoup plus courte.

Voici quelques exemples qui comparent le code Laravel avec le code Adonis.js. Voir les similitudes :
Laravel route
```php
Route::get('/', [PostController::class, 'index']);
```

Adonis route
```js
Route.get('/', 'PostsController.index')
```

Laravel migrations
```php
public function up() {
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->timestamps();
        $table->string('title');
        $table->text('content');
    });
}
```

Adonis migrations
```js
protected tableName = 'posts'
public async up () {
    this.schema.createTable(this.tableName, (table) => {
      table.increments('id')
      table.timestamps(true)
      table.string('title')
      table.text('content')
    })
  }
```

Laravel controller:
```php
class BlogController extends Controller
{   
    public function index()
    {
        $posts = Post::all();
        return view('posts.index', ['posts', $posts]);
    }
```

Adonis controller
```js
export default class PostsController {
  public async index (ctx: HttpContextContract) {
    const posts = await Post.all()
    return ctx.view.render('posts/index', {posts})
  }
```

Laravel view (blade)
```jinja
@extends('layouts.app')

@section('content')
<h1>Welcome to my Blog</h1>
    @foreach($posts as $post)
      <h3>{{post->id}}. <a href="{{ route('PostsController.show', $post)}}">{{ post->title }}</a></h3> <br>
      {{ post->content }} <br><br><hr>
    @endforeach
@endsection
```

Adonis view (edge)
```jinja
@layout('app')

@section('page')
    <h1>Welcome to my Blog</h1>
    @each(post in posts)
      <h3>{{post.id}}. <a href="{{ route('PostsController.show', {id: post.id})}}">{{ post.title }}</a></h3> <br>
      {{ post.content }} <br><br><hr>
    @endeach
@endsection 
```

Comme vous pouvez le voir, la courbe d'apprentissage est assez faible.

Mais tout n'est pas pareil par exemple. Dans Adonis, le modèle est explicitement déclaré dans le fichier modèle. Dans Laravel, le modèle n'est défini que dans le fichier de migration.

Fichier modèle Adonis :
```js
export default class Post extends BaseModel {
  @column({ isPrimary: true })
  public id: number

  @column.dateTime({ autoCreate: true })
  public createdAt: DateTime

  @column.dateTime({ autoCreate: true, autoUpdate: true })
  public updatedAt: DateTime

  @column()
  public title: string

  @column()
  public content: string

}
```

<h2>Conclusion</h2>
C'est tout pour aujourd'hui. Restez à l'écoute car je publierai de nombreux autres articles sur Adonis.js dans un avenir proche.