2 Sequelize hooks explained (analogy)

Sequelize beforeCreate hook analogy

The beforeCreate hook in Sequelize could be thought of how a chef preparing a meal before cooking it. A chef will prepare the ingredients, marinades the meat, and adds spices before cooking, the beforeCreate hook allows you to prepare the data before it is saved to the database.

For example, let’s say you’re making a pizza. You start with a dough, then add tomato sauce, cheese, and other toppings before baking it in the oven. Similarly, when creating a new instance of a model in Sequelize, you start with some initial data. Then use the beforeCreate hook to modify that data before it is saved to the database.

In the pizza analogy, you could use the beforeCreate hook to add a special sauce to the pizza before it is baked, or to ensure that there are no duplicate toppings. Similarly, in Sequelize, you can use the beforeCreate hook to add default values to fields, validate data, or set relationships between models.

The beforeCreate allows you to make sure the data is in the right format and has the right values before saving it to the database. Just like how a chef makes sure the ingredients are prepared correctly before cooking a meal.

Simple Sequelize beforeCreate hook

Sequelize comes with a variety of features, including hooks, which allow you to intercept and manipulate the data before or after certain events occur.

The beforeCreate hook is one hook provided by Sequelize. This hook called right before a new instance is created and saved to the database. It allows you to modify the data that is about to be created, such as validating or transforming values, adding default values, or setting relationships with other models.

Here is an example of using the beforeCreate hook to automatically generate a unique identifier for a new user:

const { Sequelize, Model } = require('sequelize');

class User extends Model {}

User.init({
  id: {
    type: Sequelize.UUID,
    defaultValue: Sequelize.UUIDV4,
    primaryKey: true,
  },
  name: {
    type: Sequelize.STRING,
    allowNull: false,
  },
  email: {
    type: Sequelize.STRING,
    allowNull: false,
    unique: true,
  },
}, { sequelize });

User.beforeCreate((user, options) => {
  user.id = user.id || uuidv4();
});

The beforeCreate hook is used to set the id field of the user to a newly generated UUID if it doesn’t already exist. This ensures that every new user will have a unique identifier. Note that the beforeCreate hook takes two arguments: the instance of the model being created, and an options object. In this case, we are only using the instance argument.

Sequelize beforeUpdate hook analogy

The beforeUpdate hook could be though of as a chef preparing a dish before serving it to a customer.

Imagine a chef who is preparing a dish for a customer. Before the dish is served, the chef needs to make sure that the dish is cooked properly, seasoned correctly, and presented nicely. The beforeUpdate hook in Sequelize works in a similar way.

When an update operation is performed on a Sequelize model instance. The beforeUpdate hook is called before the changes are saved to the database. Just like the chef preparing a dish, the beforeUpdate hook allows you to modify the data in the model instance before it is saved to the database.

For example, you could use the beforeUpdate hook to validate the data in the model instance, sanitize the input, or apply any necessary transformations to the data. This is similar to the chef seasoning the dish, adjusting the temperature, or adding garnishes to make it look nicer.

The beforeUpdate hook is a powerful tool that allows you to customize the behavior of your Sequelize models and ensure that the data in your database is consistent and properly formatted, much like a chef ensuring that the dish they serve is of high quality and meets the customer’s expectations.

Simple Sequelize beforeCreate hook

The beforeUpdate hook is one lifecycle hooks provided by Sequelize. It is called before an update operation is executed on a model instance. This allows you to modify the instance’s data before it is saved to the database.

The beforeUpdate hook takes two arguments: the instance being updated and the options object. You can use these arguments to modify the data, perform validations, or perform any other operations that you need to do before the update.

In the example below we are modifying the instance data when .update() is called on the model.

const User = sequelize.define('User', {
  name: Sequelize.STRING,
  email: Sequelize.STRING,
  password: Sequelize.STRING,
});

User.beforeUpdate((user, options) => {
  // Hash the password before updating the user
  user.password = hash(user.password);
});