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

Saad Majeed — Sat, 02 May 2026 04:52:32 +0000

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);
}

Routing in BushJS - NodeJS framework

Saad Majeed — Mon, 20 Apr 2026 14:38:23 +0000

Routing in BushJS (HTTP):
BushJS has a very easy and simple way to handle routing.
For basic routes, you can use:

app.get(path, handler) app.post(path, handler)

path → the route URL (e.g. /users)
handler → the function that runs when the route is called

But HTTP has more methods than just GET and POST.
To use all methods, you can access the router:

app.router.get(path, handler) app.router.post(path, handler) app.router.put(path, handler) app.router.delete(path, handler) app.router.any(path, handler) app.router.resource(name, controller) app.router.apiResource(name, controller)

Example

app.get('/users', (req, res) => { res.send('All users')

})

Meet BushJS, a new Nodejs framework

Saad Majeed — Sat, 18 Apr 2026 05:36:47 +0000

Welcome to BushJS

I'm a Nodejs framework built on top of Express.js and MongoDB. Right now, I'm for APIs only, so you will be using me to develop RESTful APIs, GraphQL, and WebSocket endpoints.

I do support Models, Controllers, Requests, Responses, routes, migrations, seeders, and many more.

Wanna try me? But hear! I do support CLI commands that will boost your productivity.

You can install my CLI by running this command:
npm install -g bushjs-cli

After installing this, you will obviously create a new project via this command:
npx bush new <project-name>

This command will create a new folder/directory with the name of the project you gave in the command. Step into that folder/directory and run this npm command just like normal ones
npm install

As we know, this will install the required dependencies into the node_modules folder/directory that runs our Nodejs project.

Now what? No headache! Run this command to run our new BushJS project just as usual:
npm run dev

Is it final? Absolutely not! BushJS means I do support my built-in commands for other operations, like creating controllers, routes, models, migrations, seeders, and many more.
node bush <command>

Did you find me interesting? Let's dive deeper into the docs!

BushJS Docs

You can also search me on NPMJS Website
and this BushJS CLI too!

DEV Community: Saad Majeed

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

Routing in BushJS - NodeJS framework

Meet BushJS, a new Nodejs framework

Welcome to BushJS