Sling Academy
Home/Node.js/Using afterCreate and afterUpdate hooks in Sequelize.js

Using afterCreate and afterUpdate hooks in Sequelize.js

Last updated: December 29, 2023

Introduction

In the world of web development, particularly when dealing with databases, the concept of hooks presents a powerful way of running custom code in response to specific events within a lifecycle of an ORMs model instance. Sequelize, a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite, and Microsoft SQL Server, provides a comprehensive set of hooks that developers can utilize. This tutorial focuses on two commonly used hooks in Sequelize.js: afterCreate and afterUpdate.

Before diving into specifics, we should clarify that hooks, also known as lifecycle events, are functions which are called before and after calls in Sequelize to the underlying database. They can be used to perform operations such as validation, modification of the data, or logging actions asynchronously or synchronously. They are crucial for maintaining data integrity and implementing business logic constraints.

Using Hooks in Sequelize

The two hooks we’re addressing, afterCreate and afterUpdate, are called after a new instance has been created and saved to the database (afterCreate), and after an existing instance has been updated and the changes saved (afterUpdate). This could include scenarios like updating a timestamp, notifying some other part of your system about the update, or even queuing jobs for further processing.

Basic Usage

// Define a model
const User = sequelize.define('user', {
  username: Sequelize.STRING
}, {
  // Define the model's hooks
  hooks: {
    afterCreate: (record) => {
      console.log(`A new user with id $
      record.id
 was created.`);
    },
    afterUpdate: (record) => {
      console.log(`User with id $
      record.id
 has been updated.`);
    }
  }
});

The above code snippet demonstrates how to define afterCreate and afterUpdate hooks directly within the model’s definition. Every time a User is created or updated, the corresponding hook will log a message to the console, providing immediate feedback.

Individual Hook Definition

User.afterCreate((record, options) => {
  console.log(`A User with username $
  record.username
 has been created.`);
});

User.afterUpdate((record, options) => {
  console.log(`User $
  record.username
 has been updated.`);
});

This approach separates the hook’s definition from the model itself, helping clean up the model’s definition and can be particularly useful for complex hooks that may have external dependency or require substantial amounts of code.

Async Hook Implementation

Hooks can also be written to perform asynchronous actions like database operations or API calls. Thanks to Sequelize’s promise-based structure, you can return a promise in the hook function, and Sequelize will wait for the promise to be resolved or rejected before continuing. This means you can perform asynchronous validations, updates, or any other asynchronous action from within a hook.

User.afterCreate(async (record, options) => {
  // Assume we send a welcome email in an asynchronous function
  await sendWelcomeEmail(record.email);
  console.log('Sent a welcome email to ', record.email);
});

The async/await syntax allows for a much neater and more understandable flow in asynchronous operations.

Modifying the Passed Instance

In afterUpdate hooks, there could arise a requirement to alter the instance after it’s been updated. Be cautious with this, as it does not persist any changes to the database but it allows you to modify the instance that other hooks or later code may rely on.

User.afterUpdate((record, options) => {
  record.updatedAt = new Date();
});

This is a simple, somewhat contrived example as Sequelize automatically handles timestamps such as updatedAt, but it serves to illustrate the point.

Complex Hook Logic and Error Handling

Oftentimes, hooks will need to go beyond simple logging examples. They can be setup to interface with other services, enforce business logic, and handle more complex cases. Error handling is important, especially in hooks that can fail, as hook errors will propagate and may cause database transactions to be rolled back.

User.afterCreate(async (record, options) => {
  try {
    // Complex business logic
  } catch (error) {
    // Handle Error
  }
});

Correctly managing error handling and promises ensures that your application is robust and can appropriately handle failures during the lifecycle events of your models.

Conditional Execution in Hooks

There may be instances where you only want a hook to execute under certain conditions. Using the second argument options or inspecting the instance itself can give you this control.

User.afterUpdate((record, options) => {
  if (record.needsVerificationEmail) {
    sendVerificationEmail(record);
  }
});

This capability can lead to a very tightly tailored behavior linked directly to the state of the model and its attributes.

Conclusion

The afterCreate and afterUpdate hooks are extremely useful tools in managing after-effects of database operations and ensuring certain procedures are followed when data changes. Proper utilization can significantly revamp the capabilities of your application, automate cumbersome tasks, and maintain a healthy logic separation.

As with all powerful tools, they should be used responsibly, keeping in mind transaction integrity, the readability of your code, and performance. Introducing asynchronous operations within hooks can sometimes delay responsive times, for better or for worse, so these decisions should be weighed accordingly. With careful planning and a good understanding of these hooks, they can become a valuable asset in your Sequelize toolkit.

Next Article: Sequelize.js: Select Rows by Last Day, Last Week, Last Month, and Other Date Ranges

Previous Article: Using beforeCreate and beforeUpdate hooks in Sequelize.js

Series: Sequelize.js Tutorials

Node.js

You May Also Like

  • NestJS: How to create cursor-based pagination (2 examples)
  • Cursor-Based Pagination in SequelizeJS: Practical Examples
  • MongooseJS: Cursor-Based Pagination Examples
  • Node.js: How to get location from IP address (3 approaches)
  • SequelizeJS: How to reset auto-increment ID after deleting records
  • SequelizeJS: Grouping Results by Multiple Columns
  • NestJS: Using Faker.js to populate database (for testing)
  • NodeJS: Search and download images by keyword from Unsplash API
  • NestJS: Generate N random users using Faker.js
  • Sequelize Upsert: How to insert or update a record in one query
  • NodeJS: Declaring types when using dotenv with TypeScript
  • Using ExpressJS and Multer with TypeScript
  • NodeJS: Link to static assets (JS, CSS) in Pug templates
  • NodeJS: How to use mixins in Pug templates
  • NodeJS: Displaying images and links in Pug templates
  • ExpressJS + Pug: How to use loops to render array data
  • ExpressJS: Using MORGAN to Log HTTP Requests
  • NodeJS: Using express-fileupload to simply upload files
  • ExpressJS: How to render JSON in Pug templates