تجربه من با AdonisJS و نحوه ساخت اولین CRUD خود

# Instale a CLI do AdonisJS globalmente se ainda não tiver
npm install -g @adonisjs/cli

# Crie um novo projeto AdonisJS
adonis new tasks-app

# Navegue até a pasta do projeto
cd tasks-app

# Instale as dependências
npm install

// config/database.ts
const databaseConfig: DatabaseConfig = {
  connection: 'sqlite',

  connections: {
    sqlite: {
      client: 'sqlite3',
      connection: {
        filename: path.join(__dirname, '..', 'database.sqlite')
      },
      useNullAsDefault: true,
      migrations: {
        naturalSort: true,
      },
      healthCheck: false,
      debug: false,
    },
    // Outras configurações de banco de dados...
  }
}

# Criar uma migração para a tabela de tarefas
adonis make:migration tasks --create=tasks

import BaseSchema from '@ioc:Adonis/Lucid/Schema'

export default class Tasks extends BaseSchema {
  protected tableName = 'tasks'

  public async up () {
    this.schema.createTable(this.tableName, (table) => {
      table.increments('id')
      table.string('title').notNullable()
      table.text('description')
      table.boolean('is_completed').defaultTo(false)
      table.timestamps(true)
    })
  }

  public async down () {
    this.schema.dropTable(this.tableName)
  }
}

adonis migration:run

# Criar o modelo Task
adonis make:model Task

import { DateTime } from 'luxon'
import { BaseModel, column } from '@ioc:Adonis/Lucid/Orm'

export default class Task extends BaseModel {
  @column({ isPrimary: true })
  public id: number

  @column()
  public title: string

  @column()
  public description: string

  @column()
  public isCompleted: boolean

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

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

# Criar o controlador TaskController
adonis make:controller Task

import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import Task from 'App/Models/Task'

export default class TaskController {
  public async index({ response }: HttpContextContract) {
    const tasks = await Task.all()
    return response.json(tasks)
  }

  public async store({ request, response }: HttpContextContract) {
    const data = request.only(['title', 'description', 'is_completed'])
    const task = await Task.create(data)
    return response.status(201).json(task)
  }

  public async show({ params, response }: HttpContextContract) {
    const task = await Task.find(params.id)
    if (!task) {
      return response.status(404).json({ message: 'Task not found' })
    }
    return response.json(task)
  }

  public async update({ params, request, response }: HttpContextContract) {
    const task = await Task.find(params.id)
    if (!task) {
      return response.status(404).json({ message: 'Task not found' })
    }

    const data = request.only(['title', 'description', 'is_completed'])
    task.merge(data)
    await task.save()

    return response.json(task)
  }

  public async destroy({ params, response }: HttpContextContract) {
    const task = await Task.find(params.id)
    if (!task) {
      return response.status(404).json({ message: 'Task not found' })
    }

    await task.delete()
    return response.status(204).json(null)
  }
}

import Route from '@ioc:Adonis/Core/Route'

Route.get('/tasks', [TaskController.'index'])
Route.post('/tasks', [TaskController.'store'])
Route.get('/tasks/:id', [TaskController.'show'])
Route.put('/tasks/:id', [TaskController.'update'])
Route.delete('/tasks/:id', [TaskController.'destroy'])

adonis serve --watch