Before and After Lifecycle Functions

Amplication plugins offer powerful lifecycle functions that allow you to customize and extend the code generation process precisely where you need it. Every event within Amplication’s plugin system exposes these lifecycle functions, giving you consistent control throughout the resource generation process.

​

Event Structure

Each event in Amplication’s plugin system follows a predictable structure, offering both before and after hooks:

export interface PluginEventType<T extends EventParams> {
  before?: PluginBeforeEvent<T>;
  after?: PluginAfterEvent<T>;
}

• before: This function executes before Amplication emits the main event logic. Use it to modify event parameters and tailor the default behavior before it happens.
• after: This function executes after Amplication’s core event logic. It provides access to the generated modules or files, allowing you to apply transformations, add custom logic, or restructure outputs.

Each event defines its specific EventParams interface (T extends EventParams), providing you with type-safe access to the relevant data for that particular stage of the generation process.

export interface EventParams {}

​

Function Signatures

Let’s examine the signatures of the before and after functions to understand how you can interact with Amplication’s code generation:

export type PluginBeforeEvent<T extends EventParams> = (
  dsgContext: DsgContext,
  eventParams: T
) => Promisable<T>;

export type PluginAfterEvent<T extends EventParams, F> = (
  dsgContext: DsgContext,
  eventParams: T,
  files: FileMap<F>
) => Promisable<FileMap<F>>;

export type PluginBeforeEvent<T extends EventParams> = (
  dsgContext: DsgContext,
  eventParams: T
) => Promisable<T>;

export type PluginAfterEvent<T extends EventParams, F> = (
  dsgContext: DsgContext,
  eventParams: T,
  files: FileMap<F>
) => Promisable<FileMap<F>>;

export type PluginBeforeEvent<T extends EventParams> = (
  dsgContext: DsgContext,
  eventParams: T
) => Promisable<T>;

export type PluginAfterEvent<T extends EventParams> = (
  dsgContext: DsgContext,
  eventParams: T,
  modules: ModuleMap
) => Promisable<ModuleMap>;

export type PluginBeforeEvent<T extends EventParams> = (
  dsgContext: DsgContext,
  eventParams: T
) => Promisable<T>;

export type PluginAfterEvent<T extends EventParams, F> = (
  dsgContext: DsgContext,
  eventParams: T,
  files: FileMap<F>
) => Promisable<FileMap<F>>;

Parameters:

Return Values:

​

The Context Object

Both before and after lifecycle functions have access to a global context object that provides essential data and utilities. This context is shared between events and contains crucial information about your application.

Here are the key properties available in the context object:

​

Skipping Default Behavior

The before function provides a powerful capability to skip Amplication’s default behavior through the context object. This allows you to completely override the default functionality with your own implementation:

// In your before function
context.utils.skipDefaultBehavior = true;

By default, skipDefaultBehavior is set to false. When set to true, Amplication will skip its default implementation, and you must provide alternative logic either in the before function or in the corresponding after function.

​

Practical Use: Modifying Generated Files in after Functions

A common use case for after functions is to restructure the generated files. Imagine you need to enforce a specific folder structure for all your organization’s services. The after function is the perfect place to achieve this.

For example, you might want to:

• Move all generated GraphQL resolvers into a dedicated resolvers directory.
• Organize entity-related files into entity-specific sub folders.
• Add custom documentation or README files to specific directories.

The after function gives you the flexibility to manipulate the generated ModuleMap or FileMap and reorganize files as needed to meet your project’s architectural requirements.

​

Explore Real-World Examples

The best way to understand the power of before and after functions is to see them in action.

We encourage you to dive into the code of Amplication’s official plugins. These plugins are built using the same plugin framework and provide numerous practical examples of how to implement before and after lifecycle functions for various customization tasks.

By exploring these examples, you can gain insights into:

• Modifying code templates to inject custom logic.
• Adding new files and modules to the generated output.
• Integrating with external services and APIs during generation.
• Enforcing coding standards and best practices through automated modifications.

​

Best Practices and Important Considerations

To ensure your plugins are robust and maintainable, keep these best practices in mind when working with before and after functions: