Ölçeklenebilir Kullanıcı Bildirim Sistemi: Mimari ve Veritabanı Tasarımı

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 {      // Kullanıcının var olduğunu ve aktif olduğunu kontrol et      const user = await this.getUserWithPreferences(event.userId);      if (!user?.isActive) {        await this.analytics.trackSkipped(event.id, 'user_inactive');        return;      }
      // Kullanıcı tercihlerini filtrele      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 kontrolü      const rateLimitResult = await this.rateLimiter        .checkLimits(event.userId, event.type);            if (!rateLimitResult.allowed) {        await this.scheduleRetry(event, rateLimitResult.retryAfter);        return;      }
      // Her aktif kanal için işlem yap      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 kullanıcı verisiyle    const template = await this.templateService.getTemplate(      event.type,      channel,      user.locale    );
    const renderedContent = await this.templateService.render(      template,      { ...event.data, user }    );
    // Uygun kanal handler'ına yönlendir    return await this.channelRouter.deliver(      channel,      user,      renderedContent,      event.metadata    );  }}

class PreferenceManager {  async getEnabledChannels(    userId: string,     notificationType: string  ): Promise<NotificationChannel[]> {        // Global kullanıcı tercihlerini kontrol et    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) {      // Bu bildirim türü için default tercihleri kullan      return this.getDefaultChannels(notificationType);    }
    const currentTime = new Date();    const enabledChannels: NotificationChannel[] = [];
    for (const pref of userPrefs) {      if (!pref.enabled) continue;
      // Sessiz saatleri kontrol et      if (this.isInQuietHours(currentTime, pref)) {        // Sessiz saatleri geçersiz kılan kritik bildirim mi kontrol et        if (!this.isCriticalNotification(notificationType)) {          continue;        }      }
      // Sıklık tercihlerini kontrol et      if (!this.shouldSendBasedOnFrequency(userId, pref.frequency, notificationType)) {        continue;      }
      enabledChannels.push(pref.channel as NotificationChannel);    }
    return enabledChannels;  }
  private isInQuietHours(currentTime: Date, pref: any): boolean {    // Mevcut zamanı kullanıcının zaman dilimine çevir    const userTime = moment(currentTime)      .tz(pref.timezone || 'UTC')      .format('HH:mm:ss');
    const quietStart = pref.quiet_hours_start;    const quietEnd = pref.quiet_hours_end;
    // Gece yarısını geçen sessiz saatleri yönet    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> {        // Önce lokalize template almayı dene    let template = await this.db.findTemplate({      type: notificationType,      channel,      locale,      isActive: true    });
    // Lokalize versiyon yoksa İngilizce'ye geri dön    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 {      // Gerekli değişkenleri doğrula      await this.validateTemplateData(template, data);
      // Template'i Handlebars veya benzeri ile işle      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) {      // Template rendering hatalarını debugging için logla      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)}`    };
    // Atomik kontroller için Redis pipeline kullan    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    };
    // Limitlerle karşılaştır    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    };  }}