Make Commands

Complete reference for all make commands in AdonisJS to scaffold controllers, middleware, services, events, and other application components

AdonisJS provides a comprehensive set of make commands to quickly generate boilerplate code for various application components. All make commands support code generation via stubs and many automatically register the generated files in your application configuration.

make:command

Create a new Ace command class.

node ace make:command SendEmails
node ace make:command ProcessPayments

Options

name · string · required

Name of the command class to create

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a command file in commands/ directory:

import { BaseCommand } from '@adonisjs/core/ace'

export default class SendEmails extends BaseCommand {
  static commandName = 'send:emails'
  static description = ''

  async run() {
    this.logger.info('Hello world from SendEmails')
  }
}

make:controller

Create a new HTTP controller class.

node ace make:controller User
node ace make:controller User store update destroy
node ace make:controller User --resource
node ace make:controller User --api
node ace make:controller User --singular

Options

name · string · required

Name of the controller

actions · string[]

Create controller with custom method names

--resource · boolean

Generate resourceful controller with methods to perform CRUD actions (index, create, store, show, edit, update, destroy)

--api · boolean

Generate resourceful controller without the “edit” and “create” methods (index, store, show, update, destroy)

--singular · boolean

Generate controller in singular form

--contents-from · string

Use the contents of the given file as the generated output

Examples

Basic Controller

node ace make:controller User

Generated File

import type { HttpContext } from '@adonisjs/core/http'

export default class UsersController {
  async index({}: HttpContext) {}
  
  async create({}: HttpContext) {}
  
  async store({}: HttpContext) {}
  
  async show({}: HttpContext) {}
  
  async edit({}: HttpContext) {}
  
  async update({}: HttpContext) {}
  
  async destroy({}: HttpContext) {}
}

make:middleware

Create a new middleware class for HTTP requests.

node ace make:middleware Auth
node ace make:middleware Auth --stack=server
node ace make:middleware Auth --stack=named
node ace make:middleware Auth --stack=router

Options

name · string · required

Name of the middleware

--stack · 'server' | 'named' | 'router'

The stack in which to register the middleware. If not provided, you’ll be prompted to select one.

--contents-from · string

Use the contents of the given file as the generated output

Middleware Stacks

• server - Runs on every HTTP request before the route handler
• router - Runs on specific routes or route groups
• named - Named middleware that can be applied to specific routes

Generated File

Creates a middleware file in app/middleware/ and automatically registers it in start/kernel.ts:

import type { HttpContext } from '@adonisjs/core/http'
import type { NextFn } from '@adonisjs/core/types/http'

export default class AuthMiddleware {
  async handle(ctx: HttpContext, next: NextFn) {
    // Middleware logic
    await next()
  }
}

make:service

Create a new service class.

node ace make:service UserService
node ace make:service Auth/LoginService

Options

name · string · required

Name of the service

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a service file in app/services/:

export default class UserService {
  // Service implementation
}

make:event

Create a new event class.

node ace make:event UserRegistered
node ace make:event OrderCompleted

Options

name · string · required

Name of the event

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates an event file in app/events/:

import { BaseEvent } from '@adonisjs/core/events'

export default class UserRegistered extends BaseEvent {
  // Event properties
}

make:listener

Create a new event listener class.

node ace make:listener SendWelcomeEmail
node ace make:listener SendWelcomeEmail --event=UserRegistered

Options

name · string · required

Name of the event listener

--event · string

Generate an event class alongside the listener and bind them together

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a listener file in app/listeners/:

import UserRegistered from '#events/user_registered'

export default class SendWelcomeEmail {
  async handle(event: UserRegistered) {
    // Listener logic
  }
}

When using --event flag, it first creates the event class, then creates the listener with proper type binding.

make:exception

Create a new custom exception class.

node ace make:exception ValidationException
node ace make:exception UnauthorizedException

Options

name · string · required

Name of the exception

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates an exception file in app/exceptions/:

import { Exception } from '@adonisjs/core/exceptions'

export default class ValidationException extends Exception {
  // Exception implementation
}

make:validator

Create a new VineJS validator file.

node ace make:validator UserValidator
node ace make:validator UserValidator --resource

Options

name · string · required

Name of the validator file

--resource · boolean

Create a file with pre-defined validators for create and update actions

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Basic Validator

import vine from '@vinejs/vine'

export const userValidator = vine.compile(
  vine.object({
    // Validation rules
  })
)

make:provider

Create a new service provider class.

node ace make:provider AppProvider
node ace make:provider AppProvider --register
node ace make:provider AppProvider --no-register
node ace make:provider AppProvider --environments=web,console

Options

name · string · required

Name of the provider

--register · boolean

Auto register the provider inside the .adonisrc.ts file. If not provided, you’ll be prompted.

--environments · string[]

Define the provider environment. Accepted values are “web”, “console”, “test”, “repl”

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a provider file in providers/ and optionally registers it in .adonisrc.ts:

import type { ApplicationService } from '@adonisjs/core/types'

export default class AppProvider {
  constructor(protected app: ApplicationService) {}

  register() {
    // Register bindings
  }

  async boot() {
    // Bootstrap logic
  }

  async start() {
    // Start logic
  }

  async ready() {
    // Ready logic
  }

  async shutdown() {
    // Shutdown logic
  }
}

make:preload

Create a new preload file inside the start directory.

node ace make:preload routes
node ace make:preload events --register
node ace make:preload kernel --no-register
node ace make:preload view --environments=web

Options

name · string · required

Name of the preload file

--register · boolean

Auto register the preload file inside the .adonisrc.ts file. If not provided, you’ll be prompted.

--environments · string[]

Define the preload file’s environment. Accepted values are “web”, “console”, “test”, “repl”

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a preload file in start/ and optionally registers it in .adonisrc.ts:

// Preload file logic

make:test

Create a new Japa test file.

node ace make:test UserController
node ace make:test UserModel --suite=unit
node ace make:test AuthService --suite=integration

Options

name · string · required

Name of the test file

--suite · string

The suite for which to create the test file. If not provided and multiple suites exist, you’ll be prompted to select one.

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a test file in the appropriate suite directory (e.g., tests/unit/, tests/functional/):

import { test } from '@japa/runner'

test.group('UserController', () => {
  test('example test', async ({ assert }) => {
    assert.isTrue(true)
  })
})

make:view

Create a new Edge.js template file.

node ace make:view home
node ace make:view users/profile
node ace make:view components/navbar

Options

name · string · required

Name of the template

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a template file in resources/views/:

<!DOCTYPE html>
<html>
<head>
  <title>Page Title</title>
</head>
<body>
  
</body>
</html>

make:transformer

Create a new transformer class.

node ace make:transformer User
node ace make:transformer Post

Options

name · string · required

Entity name for which to generate the transformer

--contents-from · string

Use the contents of the given file as the generated output

Generated File

Creates a transformer file in app/transformers/:

import User from '#models/user'

export default class UserTransformer {
  transform(user: User) {
    return {
      id: user.id,
      // Transform logic
    }
  }
}

Common Flags

All make commands support the following common flag:

—contents-from

Use the contents of a specified file as the generated output instead of using the default stub template:

node ace make:controller User --contents-from=./templates/my-controller.txt
node ace make:service UserService --contents-from=./custom-service.ts

This is useful when:

• You have custom templates for specific project patterns
• You want to copy an existing file as a starting point
• You need to bypass the default stub templates

Best Practices

Use consistent naming conventions

Follow AdonisJS naming conventions:

• Controllers: PascalCase, plural (e.g., UsersController)
• Services: PascalCase with “Service” suffix (e.g., UserService)
• Middleware: PascalCase (e.g., AuthMiddleware)
• Events: PascalCase, past tense (e.g., UserRegistered)
• Validators: camelCase with “Validator” suffix (e.g., userValidator)

Organize with namespaces

Use directory separators to organize related files:

node ace make:controller Admin/UsersController
node ace make:service Auth/LoginService
node ace make:event User/Registered

Choose the right controller type

• Use --resource for full CRUD with web views (includes create and edit)
• Use --api for REST APIs without view-rendering actions
• Use custom actions for specific use cases (e.g., login, logout, register)

Leverage auto-registration

Use --register flags when creating providers and preload files to automatically add them to .adonisrc.ts:

node ace make:provider CacheProvider --register --environments=web,console
node ace make:preload routes --register --environments=web