AdonisJS

To register multiple encryption configurations (e.g., a primary and a secondary encryptor), extend the EncryptorsList interface. This enables the EncryptionService to manage multiple encryption keys or configurations.

// Extending EncryptorsList in user code
declare module '@adonisjs/core' {
  interface EncryptorsList {
    default: EncryptionConfig
    secondary: EncryptionConfig
  }
}

The HttpServerProcess implements several lifecycle management patterns to ensure stability:

1. Initialization: It triggers the application's init() and boot() phases before the server starts listening.
2. Graceful Shutdown: It listens for the application's terminating event. When triggered, it calls the underlying Node.js server's .close() method to stop accepting new connections.
3. Error Monitoring: It monitors the Node.js server for 'error' events. If the server crashes, it logs a fatal error, sets the process exit code to 1, and calls app.terminate() to shut down the application.
4. Startup Notification: Once the server is listening, it notifies the system via:
   • The application's notify method (with isAdonisJS: true and environment: 'web').
   • The logger service.
   • The emitter service via the http:server_ready event.

To register custom loggers that are available via the logger service, extend the LoggersList interface using module augmentation. This allows the LoggerService to provide type-safe access to your specific logger configurations.

// Extending LoggersList in user code
declare module '@adonisjs/core' {
  interface LoggersList {
    default: LoggerConfig
    file: LoggerConfig
  }
}

To add custom hashing algorithms (drivers) to the hash service, extend the HashersList interface. This allows you to use different hashing strategies defined in your configuration.

// Extending HashersList in user code
declare module '@adonisjs/core' {
  interface HashersList {
    scrypt: ManagerDriverFactory
    argon: ManagerDriverFactory
  }
}

When using make:controller, certain flags have precedence or conflicts:

• Custom Actions vs Resource Flags: If you provide custom method names via actions, the --resource and --api flags are ignored. The command will log a warning and use the actions stub instead.
• API vs Resource: The --api flag and --resource flag cannot be used together. If both are provided, --api takes precedence and --resource is ignored. The command will log a warning.

Configuration providers are an abstraction used to defer the resolution of configuration until the application is fully booted. This pattern is essential when configuration depends on other application services (like environment variables or other providers) that are not available during the initial module loading phase.

Instead of passing a static object, you pass a ConfigProvider which contains a resolver function. The lifecycle involves:

1. Creation: Defining the provider using configProvider.create().
2. Resolution: Calling configProvider.resolve(app, provider) during the application boot process to transform the provider into the final configuration object.

AdonisJS uses a type-safe event system. To add your own custom events and define their payload types, you must extend the EventsList interface using TypeScript module augmentation. This ensures that when you use the emitter service, your custom events are recognized and type-checked.

// Extending EventsList in user code
declare module '@adonisjs/core' {
  interface EventsList {
    'user:created': { user: User }
    'order:placed': { orderId: string, amount: number }
  }
}

When using the AdonisJS CLI to generate a new command, the resulting file follows a specific structure based on the BaseCommand class. A generated command includes a static commandName for the CLI entrypoint, a description, and an options object for defining flags and arguments.

Note that the generator uses placeholders like {{ commandName }} and {{ commandTerminalName }} which are resolved during the scaffolding process to create the class name and the CLI command string respectively.

import { BaseCommand } from '@adonisjs/core/ace'
import type { CommandOptions } from '@adonisjs/core/types/ace'

export default class MyCommand extends BaseCommand {
  static commandName = 'my:command'
  static description = 'A description of what this command does'

  static options: CommandOptions = {}

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

To use the recommended ESLint configuration for AdonisJS projects, import configPkg from @adonisjs/eslint-config and export it as the default configuration in your eslint.config.js file. You can pass an options object to configPkg to define global ignores for the linting process.

import { configPkg } from '@adonisjs/eslint-config'

export default configPkg({
  ignores: ['coverage'],
})