Building a Scalable User Notification System: Architecture and Database Design

interface NotificationEvent {  id: string;  userId: string;  type: NotificationType;  templateId?: string;  data: Record<string, any>;  priority: 'low' | 'normal' | 'high' | 'critical';  scheduledAt?: Date;  expiresAt?: Date;  metadata: {    source: string;    correlationId: string;    retryCount: number;    maxRetries: number;  };}
enum NotificationType {  PROJECT_UPDATE = 'project_update',  SECURITY_ALERT = 'security_alert',   FEATURE_ANNOUNCEMENT = 'feature_announcement',  SYSTEM_MAINTENANCE = 'system_maintenance',  USER_ACTIVITY = 'user_activity',  INTEGRATION_UPDATE = 'integration_update'}

class NotificationEngine {  constructor(    private eventBus: EventBus,    private templateService: TemplateService,    private preferenceManager: PreferenceManager,    private rateLimiter: RateLimiter,    private channelRouter: ChannelRouter,    private analytics: AnalyticsService  ) {}
  async processEvent(event: NotificationEvent): Promise<void> {    try {      // Check if user exists and is active      const user = await this.getUserWithPreferences(event.userId);      if (!user?.isActive) {        await this.analytics.trackSkipped(event.id, 'user_inactive');        return;      }
      // Apply user preferences filtering      const enabledChannels = await this.preferenceManager        .getEnabledChannels(event.userId, event.type);            if (enabledChannels.length === 0) {        await this.analytics.trackSkipped(event.id, 'all_channels_disabled');        return;      }
      // Rate limiting check      const rateLimitResult = await this.rateLimiter        .checkLimits(event.userId, event.type);            if (!rateLimitResult.allowed) {        await this.scheduleRetry(event, rateLimitResult.retryAfter);        return;      }
      // Process each enabled channel      const deliveryPromises = enabledChannels.map(channel =>         this.processChannel(event, channel, user)      );
      const results = await Promise.allSettled(deliveryPromises);      await this.analytics.trackDeliveryResults(event.id, results);
    } catch (error) {      await this.handleProcessingError(event, error);    }  }
  private async processChannel(    event: NotificationEvent,    channel: NotificationChannel,    user: User  ): Promise<DeliveryResult> {    // Template rendering with user data    const template = await this.templateService.getTemplate(      event.type,      channel,      user.locale    );
    const renderedContent = await this.templateService.render(      template,      { ...event.data, user }    );
    // Route to appropriate channel handler    return await this.channelRouter.deliver(      channel,      user,      renderedContent,      event.metadata    );  }}

class PreferenceManager {  async getEnabledChannels(    userId: string,     notificationType: string  ): Promise<NotificationChannel[]> {        // Check global user preferences    const userPrefs = await this.db.query(`      SELECT np.channel, np.enabled, np.frequency,              np.quiet_hours_start, np.quiet_hours_end,             u.timezone      FROM notification_preferences np      JOIN users u ON u.id = np.user_id      WHERE np.user_id = $1 AND np.notification_type = $2    `, [userId, notificationType]);
    if (userPrefs.length === 0) {      // Use default preferences for this notification type      return this.getDefaultChannels(notificationType);    }
    const currentTime = new Date();    const enabledChannels: NotificationChannel[] = [];
    for (const pref of userPrefs) {      if (!pref.enabled) continue;
      // Check quiet hours      if (this.isInQuietHours(currentTime, pref)) {        // Check if this is a critical notification that overrides quiet hours        if (!this.isCriticalNotification(notificationType)) {          continue;        }      }
      // Check frequency preferences      if (!this.shouldSendBasedOnFrequency(userId, pref.frequency, notificationType)) {        continue;      }
      enabledChannels.push(pref.channel as NotificationChannel);    }
    return enabledChannels;  }
  private isInQuietHours(currentTime: Date, pref: any): boolean {    // Convert current time to user's timezone    const userTime = moment(currentTime)      .tz(pref.timezone || 'UTC')      .format('HH:mm:ss');
    const quietStart = pref.quiet_hours_start;    const quietEnd = pref.quiet_hours_end;
    // Handle quiet hours that cross midnight    if (quietStart > quietEnd) {      return userTime >= quietStart || userTime <= quietEnd;    }
    return userTime >= quietStart && userTime <= quietEnd;  }}

interface Template {  id: string;  name: string;  type: string;  channel: string;  locale: string;  subject?: string;  body: string;  variables: Record<string, TemplateVariable>;  abTest?: ABTestConfig;}
class TemplateService {  async getTemplate(    notificationType: string,    channel: NotificationChannel,    locale: string = 'en'  ): Promise<Template> {        // Try to get localized template first    let template = await this.db.findTemplate({      type: notificationType,      channel,      locale,      isActive: true    });
    // Fallback to English if no localized version    if (!template && locale !== 'en') {      template = await this.db.findTemplate({        type: notificationType,        channel,        locale: 'en',        isActive: true      });    }
    if (!template) {      throw new Error(`No template found for ${notificationType}/${channel}/${locale}`);    }
    return template;  }
  async render(template: Template, data: Record<string, any>): Promise<RenderedContent> {    try {      // Validate required variables      await this.validateTemplateData(template, data);
      // Process template with Handlebars or similar      const subject = template.subject         ? await this.renderString(template.subject, data)        : undefined;
      const body = await this.renderString(template.body, data);
      return {        subject,        body,        templateId: template.id,        locale: template.locale      };
    } catch (error) {      // Log template rendering errors for debugging      await this.logger.error('Template rendering failed', {        templateId: template.id,        error: error.message,        data: this.sanitizeDataForLogging(data)      });            throw new TemplateRenderError(`Failed to render template ${template.id}`, error);    }  }}

interface RateLimitConfig {  notificationType: string;  channel: string;  limits: {    perMinute: number;    perHour: number;    perDay: number;  };  burstAllowance: number;}
class RateLimiter {  constructor(private redis: Redis, private configs: RateLimitConfig[]) {}
  async checkLimits(    userId: string,     notificationType: string  ): Promise<RateLimitResult> {        const config = this.getConfig(notificationType);    if (!config) {      return { allowed: true, remainingToday: Infinity };    }
    const now = Date.now();    const keys = {      minute: `rate_limit:${userId}:${notificationType}:${Math.floor(now / 60000)}`,      hour: `rate_limit:${userId}:${notificationType}:${Math.floor(now / 3600000)}`,      day: `rate_limit:${userId}:${notificationType}:${Math.floor(now / 86400000)}`    };
    // Use Redis pipeline for atomic checks    const pipeline = this.redis.pipeline();    pipeline.incr(keys.minute);    pipeline.expire(keys.minute, 60);    pipeline.incr(keys.hour);    pipeline.expire(keys.hour, 3600);    pipeline.incr(keys.day);    pipeline.expire(keys.day, 86400);
    const results = await pipeline.exec();    const counts = {      minute: results[0][1] as number,      hour: results[2][1] as number,      day: results[4][1] as number    };
    // Check against limits    if (counts.minute > config.limits.perMinute ||        counts.hour > config.limits.perHour ||        counts.day > config.limits.perDay) {            return {        allowed: false,        retryAfter: this.calculateRetryAfter(counts, config),        remainingToday: Math.max(0, config.limits.perDay - counts.day)      };    }
    return {      allowed: true,      remainingToday: config.limits.perDay - counts.day    };  }}