• Install MySQL workbench in your local system as we will be using MySQL for our DB

• Install npm which is our package manager (download the version labelled as LTS)

• Install Adonis.js globally (adonis 4.1)

• Install Postman and create a new collection for the API endpoints for future testings as follows -

  • Two endpoints for user

    POST: auth/register 
    POST: auth/login
    

  • Five endpoints for projects

    GET: projects
    GET: projects/:id
    PUT: projects
    PATCH: projects/:id
    DELETE: projects/:id
    

  • Five endpoints for tasks

    GET: tasks
    GET: tasks/:id
    PUT: tasks
    PATCH: tasks/:id
    DELETE: tasks/:id
    

• Create the adonis boilerplate by

  adonis new server
  

• Create an SQL schema in MySQL workbench and save the credentials, schema name in the .env

• Feel free to change the server running PORT in .env if needed

Congrats!! your initial set up for the backend is done.

• Adonis has a very strong feature of lucid models which helps to communicate with the database without writing SQL queries directly.
• Migrations are scripts that help to create, reset refresh database tables. Migrations are very useful since you don't have to create tables manually. To learn more about migration & model, follow the references given.
• As you have the adonis boilerplate already, you will find there is a user and token model already along with their migration scripts. Similarly, we need our project & task model with all the relationships defined & migration scripts with the attributes. Following are my tables. Feel free to add more attributes if you want to.

• To create a migration script for a table,

adonis make:migration <table name>

• After the migration scripts are ready, run the migrations.

adonis migration:run

Below is an example to refer to creating the project migration script.

class ProjectSchema extends Schema {
  up () {
    this.create('projects', (table) => {
      table.increments()
      table.integer('user_id').unsigned().references('id').inTable('users')
      table.string('title', 5000)
      table.timestamps()
    })
  }
 
  down () {
    this.drop('projects')
  }
}

• Create your models accordingly for projects, tasks, users to define the relationship. Discussing the relationship,
  • a user can have many project (HasMany<->BelongsTo)
  • a project can have many tasks (HasMany<->BelongsTo)

Below is the example you can refer to:

class Project extends Model {
 
    user(){
        return this.belongsTo('App/Models/User');
    }
    tasks () {
        return this.hasMany('App/Models/Task')
    }
}

• Since Adonis follows MVC design pattern, controllers are there to handle requests and responses. Controllers collect requests & run lucid query builders to communicate with the database and send the response back. You can create a controller for the corresponding model by

adonis make:controller <Model_name> --type http

• For a CRUD operation, there are mainly 5 types of requests. For example, in the projects table we will have,

GET: projects - request to return all projects
 
GET: projects/:id - request to return a particular project (id given in params)
 
PUT: projects - request for creating a project (payload to be provided in the request body) 
 
PATCH: projects/:id - request for updating a project (payload to be provided in the request body, id given in params)
 
DELETE: projects/:id - request for deleting a project

So the project controller should have functions to handle all these requests and should be routed through created endpoints.

• Create controllers for projects and tasks similarly to handle the CRUD operations and return applicable responses. Write the lucid query builders to communicate with the database. Use Lucid query builders like below:

/**
   * Create/save a new project.
   * POST projects
   *
   * @param {object} ctx
   * @param {Request} ctx.request
   * @param {Response} ctx.response
   */
  async store({ request, auth, response }) {
    try {
      const user = await auth.getUser();
      const { title } = request.post();
 
      const project = new Project();
      project.fill({
        title,
      });
      await user.projects().save(project);
      return response.status(200).send({
        project,
        message: 'Successfully Added project'
      })
 
    } catch (error) {
      return  response.status(error.status | 500).send(error);
    }
 
 
  }
 

• For users table, you don't need CRUD endpoints. Hence you only need -

POST: auth/register 
POST: auth/login

So write functions to register a user and implement login facilities. Use auth functions like below:

 async login({request, auth, response}){
 
        try {
            const { email, password } = request.post();
            const token = await auth.attempt(email, password);
            return token;   
        } catch (error) {
            return  response.status(error.status | 500).send(error);
        }
 
    }

• Route the endpoints towards correct controller functions by editing the route.js file. In the route.js file specify the mapping between urls & corresponding function to handle like below

Route.group(()=>{
  Route.get('/', 'ProjectController.index').middleware('auth');
  Route.put('/', 'ProjectController.store').middleware('auth');
  Route.get('/:id', 'ProjectController.show').middleware('auth');
  Route.post('/:id', 'ProjectController.update').middleware('auth');
  Route.delete('/:id', 'ProjectController.destroy').middleware('auth');
}).prefix('v1/project')

• Middlewares are something that hooks into the request lifecycle. There are a set of functions to be executed in sequence to transform the request/response. A middleware can be named, global or server. Check out the references to know more about middlewares.

• Here we will use auth as middleware which will serve the authentication purpose. 'auth' uses different authentication schemes such as basic, jwt, session etc. You can use 'jwt' as the authenticator scheme.

• Add the middleware in your routing file so that request goes through auth first.

• Whenever there is a request at the user registration endpoint, it should send back a jwt token in the response which will be used for further authentication purposes. This token should be used in sending further requests for that user. You can include the jwt token in the request header.

• Add support in controllers so that a controller keeps check of authentication. For instance, a user should not be able to fetch other users' projects. As a practice you can first fetch the user of the requested project and check whether the corresponding jwt token matches with the header jwt token or not. This is a standard practice of doing authentications.

• Whenever you delete a project for a user, all the tasks associated with the project should be deleted.
• You need to write a transaction and use that in the destroy method in the controller. Learn more about writing transactions from the references.

• In this module you will test all the APIs you have developed so far. This is a mandatory step before proceeding towards the front end part. Make sure all your endpoints are working as per expectation. Check out the responses you are receiving are correct or not.

• First create a user by sending a request to the endpoint

  {{url}}/auth/register 
  

  where {{url}} is an environment variable you should save in postman. Check out the environment tab on your upper left side. {{url}} is the base url by default http://localhost:3333. It should be the same as what is in your .env file.

As a response, you should get back the jwt token and then onwards use this auth token in the header (Authentication) to send a request to other endpoints. For instance, log in with the registered user by using the jwt token you got. say, you want to send a project PUT request for this user then, add this jwt token in the header (Authentication) to pass the auth middleware.