How to make a CRUD in Bushjs for TODO App (APIs Only)

Bushjs is a nodejs framework built on the top of express and mongodb. To make a CRUD, lets follow the following:

First of all, we will install bushjs-cli, a CLI command tool for BUSHJS framework.

npm install -g bushjs-cli

After installing this CLI, you can use this command to make a new project

bush new bushapp

You can use your own project name instead of bushapp.

You can also create a new project without installing CLI tool using

npx bush new bushapp

Using this command will include all project files in bushapp. We will go into bushapp dir/folder and install all required packages

cd bushapp
npm install

To understand project directory flow, you can use this directory structure help guide

After installing required packages, you can run your project using this command

npm run dev

We will need to define database schema for storing tasks. Bushjs has CLI command for that

node bush make:schema tasks

This command will create a new schema file at database/schemas/20260502013812_tasks.ts

This schema file comes with this schema code by default.

import { BaseSchema } from 'bushjs';

export default class TasksSchema extends BaseSchema {
  async up(): Promise<void> {
    await this.createCollection('tasks', (schema) => {
      schema.id();
      schema.string('name', 255, true);
      schema.timestamps();
    });
  }

  async down(): Promise<void> {
    await this.dropCollection('tasks');
  }
}

This schema import BaseSchema from bushjs that is later extended by TasksSchema class. This class has two methods up() and down(). up() is responsible for making schema structure in database while down() drops the database schema, means removes this schema from database.
Now we will update this tasks schema with this:
schema.string('description', 255, false);
schema.boolean('completed', false);

We will have the final schema file like this

import { BaseSchema } from 'bushjs';

export default class TasksSchema extends BaseSchema {
  async up(): Promise<void> {
    await this.createCollection('tasks', (schema) => {
      schema.id();
      schema.string('name', 255, true);
      schema.string('description', 255, false);
      schema.boolean('completed', false);
      schema.timestamps();
    });
  }

  async down(): Promise<void> {
    await this.dropCollection('tasks');
  }
}

Now, let's make a new Model using this command:

node bush make:model Task

This command will create a new file here
app/Models/Task.ts

This Task.ts file contains this code by default

import { Model } from 'bushjs';

export class Task extends Model {
  static collection = 'tasks';
  static fields = ['Task', {
    // Define your fields here
    // name: { type: 'string', required: true },
  }];
}

Now let's update this model according to schema like

import { Model } from 'bushjs';

export class Task extends Model {
  static collection = 'tasks';
  static fields = ['Task', {
    name: { type: 'string', required: true },
    description: { type: 'string', required: false },
    completed: { type: 'boolean', required: false },
  }];
}

Now, our database side is completed. Let's define logic for API endpoint handling, the Controller

node bush make:controller TaskController

This will create a new file for controller here
app/Http/Controllers/TaskController.ts

This is the controller by default file code:

import { Controller, Request, Response } from 'bushjs';

export class TaskController extends Controller {
  async index(request: Request, response: Response) {
    // TODO: Implement your logic here
    response.send('Welcome');
  }
}

Now let's update index function to show all the tasks.

import { Task } from '@app/Models/Task';
import { Controller, Request, Response } from 'bushjs';

export class TaskController extends Controller {
  async index(request: Request, response: Response) {
    const tasks = await Task.all();
    return response.json(tasks);
  }
}

Here we have imported Task Model. @ is used as a namespace like @app, @routes.

This model Task that is extended by Model class owns built-in functions of Model class. So, all() function after class is accessible as static function to retrieve all the records from database.

Now, index function is completed for defining the endpoint that we will define in routes/api.ts.

import { TaskController } from '@app/Http/Controllers/TaskController';
import { Application } from 'bushjs';

export function registerRoutes(app: Application): void {
  const Route = app.router;
  Route.get('/tasks', [TaskController, 'index']);

}

Here, we imported that TaskController class from TaskController file that we used in get() method for /tasks endpoint. Also, here app has get() and post() methods for quick usage for restful APIs. To access all the methods of Restful APIs, you have to use app.router that we used here in Route variable.

Now, Route variable has all built-in methods for Restful APIs.

Finally, we have made our first API endpoint for getting all tasks at /tasks

Now, we will define all other endpoints. For saving new record or updating existing record, we need to define some rules for request in order to match request body data according to our database schema.

For making a new Request class, let's use this command:

node bush make:request Task

This will create a TaskRequest class at app/Http/Requests/TaskRequest.ts

The TaskRequest file with defined rules(), messages() and authorize() methods.

import { FormRequest, Request } from 'bushjs';

export class TaskRequest extends FormRequest {
  protected rules(): Record<string, string[]> {
    return {
      name: ['required', 'string', 'min:2'],
      description: ['string', 'max:255'],
      completed: ['boolean'],
    };
  }

  protected messages(): Record<string, string> {
    return {
      'name.required': 'Name is required',
      'name.string': 'Name must be a string',
      'name.min': 'Name must be at least 2 characters',
      'description.string': 'Description must be a string',
      'description.max': 'Description must not exceed 255 characters',
      'completed.boolean': 'Completed must be a boolean value',
    };
  }

  async authorize(request: Request): Promise<boolean> {
    // TODO: Implement authorization logic
    return true;
  }
}

Our final TaskController for Restful APIs will be like

import { Task } from '@app/Models/Task';
import { Controller, Request, Response } from 'bushjs';
import { TaskRequest } from '../Requests/TaskRequest';

export class TaskController extends Controller {
  async index(request: Request, response: Response) {
    const tasks = await Task.all();
    return response.json(tasks);
  }

  async store(request: Request, response: Response) {
    const taskRequest = new TaskRequest();
    await taskRequest.validateRequest(request);
    const { name, description, completed } = request.body;
    const task = await Task.create({ name, description, completed });
    return response.json({ task, message: 'Task created successfully' });
  }

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

  async update(request: Request, response: Response) {
    const taskRequest = new TaskRequest();
    await taskRequest.validateRequest(request);

    const { id } = request.params;
    const { name, description, completed } = request.body;
    const task = await Task.update(id, { name, description, completed });
    if (!task) {
      return response.status(404).json({ message: 'Task not found' });
    }
    return response.json({task, message: 'Task updated successfully' });
  }

  async destroy(request: Request, response: Response) {
    const { id } = request.params;
    const task = await Task.delete(id);
    if (!task) {
      return response.status(404).json({ message: 'Task not found' });
    }
    return response.json({ message: 'Task deleted successfully' });
  }
}

And routes/api.ts will be like

import { TaskController } from '@app/Http/Controllers/TaskController';
import { Application } from 'bushjs';

export function registerRoutes(app: Application): void {
  const Route = app.router;
  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']);
}

If you use functions names like index, store, show, update and destroy then you can define routes with a single apiResource() methods and it will do all the rest things for you.

import { TaskController } from '@app/Http/Controllers/TaskController';
import { Application } from 'bushjs';

export function registerRoutes(app: Application): void {
  const Route = app.router;
  Route.apiResource('tasks', TaskController);
}