Package Model Validation in Sequelize

Understanding the Challenge

In this lesson, we'll analyze and understand a Sequelize model for a package tracking system. The challenge involves implementing proper validations and constraints on a Package model for a shipping application.

The model needs to enforce rules on various fields such as:

Let's break down the test specs and the model implementation to understand how these validations work in Sequelize.

Developing a Plan

To understand how the Package model validation works, we'll follow these steps:

  1. Examine the model and migration files to understand the database structure
  2. Analyze each test file to understand the validation requirements
  3. Study the implemented validations in the Package model
  4. Connect the tests to their corresponding model validations
  5. Explain how each validation works and why it's important
  6. Explore potential improvements or alternatives

This analysis will help us understand how Sequelize handles data validation between our application and the database.

Exploring the Solution

Database Structure

First, let's look at the migration file that defines our database table structure:


// YYYYMMDDHHMMSS-create-package.js
'use strict';

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.createTable('Packages', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      trackingNumber: {
        type: Sequelize.STRING(10),    // Enforce 10 character limit
        allowNull: false,
        unique: true                   // Each tracking number must be unique
      },
      weightKg: {
        type: Sequelize.DECIMAL(10, 2), // Allow for precise weight values
        allowNull: false
      },
      sender: {
        type: Sequelize.STRING(255),    // Maximum length of 255
        allowNull: true                 // Sender is optional
      },
      recipient: {
        type: Sequelize.STRING(255),    // Maximum length of 255
        allowNull: false                // Recipient is required
      },
      isDelivered: {
        type: Sequelize.BOOLEAN,
        allowNull: false,
        defaultValue: false             // Packages start undelivered
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
      }
    });
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable('Packages');
  }
};

This migration file sets up our database structure with SQLite constraints like allowNull, unique, and default values. These are enforced at the database level.

Model Validation Implementation

Now, let's examine how the Package model implements validations at the application level:


// package.js
'use strict';
const { Model } = require('sequelize');

module.exports = (sequelize, DataTypes) => {
  class Package extends Model {
    static associate(models) {
      // define associations here
    }
  }
  
  Package.init({
    trackingNumber: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        notEmpty: true,
        len: [10, 10],
        isUppercase: true,
        isAlphanumeric: true,
        mustHaveNumber(value) {
          if (!/[0-9]/.test(value)) {
            throw new Error('Tracking number must contain at least one number');
          }
        }
      }
    },
    weightKg: {
      type: DataTypes.DECIMAL,
      allowNull: false,
      validate: {
        notNull: true,
        min: 0.01,
        max: 500,
        rejectStringOne(value) {
          if (value === "1") {
            throw new Error('Weight must be a decimal number');
          }
        },
        isValidWeight(value) {
          if (typeof value === 'string') {
            if (!/^\\d*\\.?\\d+$/.test(value)) {
              throw new Error('Weight must be a decimal number');
            }
          } else if (!Number.isFinite(value)) {
            throw new Error('Weight must be a decimal number');
          }
        },
        notUndefined(value) {
          if (value === undefined || value === null) {
            throw new Error('Weight is required');
          }
        },
      }
    },
    sender: {
      type: DataTypes.STRING,
      validate: {
        len: [2, 255]
      }
    },
    recipient: {
      type: DataTypes.STRING,
      allowNull: false,
      validate: {
        notEmpty: true,
        len: [5, 255],
        notAnonymous(value) {
          if (value && value.toLowerCase() === 'anonymous') {
            throw new Error('Recipient cannot be Anonymous');
          }
        }
      }
    },
    isDelivered: {
      type: DataTypes.BOOLEAN,
      allowNull: false,
      defaultValue: false
    }
  }, {
    sequelize,
    modelName: 'Package',
  });
  
  return Package;
};

This model file contains both database constraints (allowNull, unique) and application-level validations within the validate objects.

Understanding Each Field Validation

trackingNumber Validation

The tracking number field has several validation requirements:

The test file (00-trackingNumber-spec.js) verifies all these constraints by testing valid values that should pass and invalid values that should fail.

weightKg Validation

The weight field verifies that:

The test file (01-weightKg-spec.js) tests these validations with various cases.

sender Validation

The sender field is optional but has certain validations:

The test file (02-sender-spec.js) verifies these validations.

recipient Validation

The recipient field has strict requirements:

The test file (03-recipient-spec.js) checks these validations.

isDelivered Validation

The delivery status field:

The test file (04-isDelivered-spec.js) tests these validations.

Timestamp Fields

The createdAt and updatedAt fields are automatically handled by Sequelize, but the migration file specifies they default to CURRENT_TIMESTAMP.

The test files (05-createdAt-spec.js and 06-updatedAt-spec.js) verify these default values work correctly.

How It All Works Together

The Test Environment

The test files use chai and chai-as-promised for testing asynchronous validations. They import utility functions:

Each test follows a similar pattern:

  1. Reset the database
  2. Test valid values (should not raise errors)
  3. Test invalid values (should raise errors)
  4. Test specific constraints like uniqueness or not null

Validation Layers

Sequelize provides two layers of validation:

  1. Application-level validation: Defined in the validate object of each field in the model. These run before any SQL is generated.
  2. Database-level constraints: Defined both in the model (allowNull, unique) and the migration file. These are enforced by the database engine.

When you try to save a Package instance:

  1. Sequelize runs all application validations
  2. If all pass, it generates and executes SQL
  3. The database applies its constraints
  4. If any validation or constraint fails, an error is thrown

Real-World Application

Why Validation Matters

In a real shipping company application, these validations would be critical:

Invalid data could lead to operational issues, customer service problems, or even legal issues if packages are lost or delivered incorrectly.

Multiple Validation Approaches

This example shows several validation techniques used in Sequelize:

  1. Built-in validators: Like notEmpty, len, isUppercase
  2. Range validations: Like min and max for numerical fields
  3. Custom validator functions: Like mustHaveNumber, notAnonymous
  4. Type validation: Ensuring values are the correct data type
  5. Database constraints: Like allowNull: false and unique: true

In complex applications, you'd typically use a combination of these approaches to ensure data integrity.

Advanced Techniques

Alternative Approaches

There are other ways to enhance our validation system:

1. Using Sequelize Hooks

We could use beforeValidate or beforeCreate hooks for more complex validations:


Package.beforeValidate((package) => {
  // Perform complex validation across multiple fields
  if (package.isDelivered && !package.deliveryDate) {
    throw new Error('Delivery date required for delivered packages');
  }
});

2. Creating Validation Modules

For complex applications, you might extract validations to separate modules:


// validations/tracking-number.js
module.exports = {
  isValidTrackingFormat(value) {
    // Complex validation logic
    return /[A-Z0-9]{10}/.test(value) && /[0-9]/.test(value);
  }
};

// In model
const trackingValidations = require('../validations/tracking-number');
// ...
validate: {
  isValidFormat(value) {
    if (!trackingValidations.isValidTrackingFormat(value)) {
      throw new Error('Invalid tracking number format');
    }
  }
}

3. Implementing Custom Error Messages

Sequelize allows you to customize error messages for better user feedback:


validate: {
  notEmpty: {
    msg: 'Tracking number cannot be empty'
  },
  len: {
    args: [10, 10],
    msg: 'Tracking number must be exactly 10 characters'
  }
}

Recap and Key Takeaways

Understanding Sequelize Validation

Sequelize provides a powerful validation system with:

Best Practices

When implementing validations:

Further Learning

To deepen your understanding of Sequelize validations:

Practice Exercise

Try implementing a model for a User with the following validations:

Write tests similar to the ones we've seen to verify your validations work correctly.