基于NestJS的电商API如何按起止日期自动启停促销活动

Hey there! Let's tackle this auto-start/end for promotions in your NestJS e-commerce API. I've got a couple of solid approaches you can use depending on your scalability needs and how precise you need the timing to be.

1. Cron Job Scheduler (Most Common) #

This approach uses scheduled background tasks to periodically check and update promotion statuses. NestJS has a built-in @nestjs/schedule module that makes this straightforward.

Step 1: Set Up Dependencies #

First, install the required packages:

npm install @nestjs/schedule @nestjs/common cron

Step 2: Configure the Schedule Module #

Add the module to your root AppModule:

import { Module } from '@nestjs/common';
import { ScheduleModule } from '@nestjs/schedule';
import { PromotionModule } from './promotion/promotion.module';

@Module({
  imports: [
    ScheduleModule.forRoot(), // Enables scheduling
    PromotionModule,
  ],
})
export class AppModule {}

Step 3: Create a Promotion Scheduler Service #

In your promotion module, make a service that runs cron jobs to check and update promotions:

import { Injectable, Logger } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Promotion } from './entities/promotion.entity';

@Injectable()
export class PromotionSchedulerService {
  private readonly logger = new Logger(PromotionSchedulerService.name);

  constructor(
    @InjectRepository(Promotion)
    private promotionRepository: Repository<Promotion>,
  ) {}

  // Run every minute (adjust cron expression as needed)
  @Cron('* * * * *')
  async handlePromotionStatusUpdate() {
    this.logger.debug('Checking promotion statuses...');
    
    const now = new Date();

    // Activate promotions that have started but aren't active yet
    await this.promotionRepository.update(
      {
        startDate: { lte: now },
        endDate: { gte: now },
        isActive: false,
      },
      { isActive: true },
    );

    // Deactivate promotions that have ended
    await this.promotionRepository.update(
      {
        endDate: { lt: now },
        isActive: true,
      },
      { isActive: false },
    );

    this.logger.debug('Promotion status sync completed');
  }
}

Tip: Adjust Cron Frequency #

If you don't need minute-by-minute precision, you can tweak the cron expression (e.g., 0 * * * * for hourly checks) to reduce database load.

2. Request-Time Validation (Real-Time Checks) #

If you want to avoid background tasks and need immediate accuracy, you can validate promotion statuses on every relevant request. This works well if you don't have thousands of promotions.

Example: Service Method to Get Active Promotions #

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Promotion } from './entities/promotion.entity';

@Injectable()
export class PromotionService {
  constructor(
    @InjectRepository(Promotion)
    private promotionRepository: Repository<Promotion>,
  ) {}

  async getActivePromotions() {
    const now = new Date();
    // Query only promotions that are currently within their date range
    return this.promotionRepository.find({
      where: {
        startDate: { lte: now },
        endDate: { gte: now },
      },
    });
  }

  // Optional: Auto-update status when fetching a single promotion
  async getPromotionById(id: string) {
    const promotion = await this.promotionRepository.findOneBy({ id });
    const now = new Date();
    
    if (!promotion) return null;

    // Update status if it's out of sync with dates
    if (promotion.startDate <= now && promotion.endDate >= now && !promotion.isActive) {
      promotion.isActive = true;
      await this.promotionRepository.save(promotion);
    } else if (promotion.endDate < now && promotion.isActive) {
      promotion.isActive = false;
      await this.promotionRepository.save(promotion);
    }

    return promotion;
  }
}

3. Delayed Tasks with a Message Queue (Precise Timing) #

For ultra-precise activation/deactivation (down to the second), use a message queue like BullMQ to schedule one-time tasks for each promotion's start and end dates.

Step 1: Set Up BullMQ #

Install dependencies:

npm install @nestjs/bull bullmq

Step 2: Configure Bull Module #

Add to AppModule:

import { Module } from '@nestjs/common';
import { BullModule } from '@nestjs/bull';
import { PromotionModule } from './promotion/promotion.module';

@Module({
  imports: [
    BullModule.forRoot({
      redis: {
        host: 'localhost',
        port: 6379,
      },
    }),
    PromotionModule,
  ],
})
export class AppModule {}

Step 3: Create Promotion Queue and Processor #

In your promotion module:

// promotion.processor.ts
import { Process, Processor } from '@nestjs/bull';
import { Job } from 'bullmq';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Promotion } from './entities/promotion.entity';

@Processor('promotions')
export class PromotionProcessor {
  constructor(
    @InjectRepository(Promotion)
    private promotionRepository: Repository<Promotion>,
  ) {}

  @Process('activate-promotion')
  async handleActivatePromotion(job: Job<{ promotionId: string }>) {
    const { promotionId } = job.data;
    await this.promotionRepository.update(promotionId, { isActive: true });
  }

  @Process('deactivate-promotion')
  async handleDeactivatePromotion(job: Job<{ promotionId: string }>) {
    const { promotionId } = job.data;
    await this.promotionRepository.update(promotionId, { isActive: false });
  }
}

Step 4: Schedule Tasks When Creating a Promotion #

// promotion.service.ts
import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bullmq';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Promotion } from './entities/promotion.entity';
import { CreatePromotionDto } from './dto/create-promotion.dto';

@Injectable()
export class PromotionService {
  constructor(
    @InjectRepository(Promotion)
    private promotionRepository: Repository<Promotion>,
    @InjectQueue('promotions') private promotionsQueue: Queue,
  ) {}

  async create(createPromotionDto: CreatePromotionDto) {
    const promotion = await this.promotionRepository.save(createPromotionDto);
    
    // Calculate delay until start date
    const startDelay = promotion.startDate.getTime() - Date.now();
    // Calculate delay until end date
    const endDelay = promotion.endDate.getTime() - Date.now();

    // Schedule activation task
    if (startDelay > 0) {
      await this.promotionsQueue.add('activate-promotion', {
        promotionId: promotion.id,
      }, { delay: startDelay });
    }

    // Schedule deactivation task
    if (endDelay > 0) {
      await this.promotionsQueue.add('deactivate-promotion', {
        promotionId: promotion.id,
      }, { delay: endDelay });
    }

    return promotion;
  }
}

Key Considerations #

• Time Zones: Always store dates in UTC in your database and handle time zone conversions consistently to avoid timing errors.
• Database Indexes: Add indexes on startDate and endDate to speed up your status check queries.
• Idempotency: When using queues or cron jobs, add checks to ensure you don't update the same promotion status multiple times (e.g., verify isActive before updating).

内容的提问来源于stack exchange，提问作者Kruger