servcraft 0.1.0 → 0.1.1

package/src/modules/notification/notification.service.ts

@@ -0,0 +1,483 @@
+import { logger } from '../../core/logger.js';
+import { BadRequestError } from '../../utils/errors.js';
+import { prisma } from '../../database/prisma.js';
+import { NotificationRepository } from './notification.repository.js';
+import type {
+  Notification,
+  NotificationConfig,
+  NotificationChannel,
+  EmailMessage,
+  SMSMessage,
+  PushMessage,
+  WebhookMessage,
+  NotificationTemplate,
+} from './types.js';
+
+/**
+ * Notification Service
+ * Manages multi-channel notifications with Prisma persistence
+ *
+ * Features:
+ * - Multi-channel support (email, SMS, push, webhook, in-app)
+ * - Persistent notification storage in database
+ * - Template system with variable substitution
+ * - Multiple provider support per channel
+ */
+export class NotificationService {
+  private config: NotificationConfig;
+  private repository: NotificationRepository;
+
+  constructor(config: NotificationConfig = {}) {
+    this.config = config;
+    this.repository = new NotificationRepository(prisma);
+  }
+
+  // ==========================================
+  // SEND NOTIFICATIONS
+  // ==========================================
+
+  /**
+   * Send a notification through a specific channel
+   */
+  async send(
+    userId: string,
+    channel: NotificationChannel,
+    title: string,
+    body: string,
+    data?: Record<string, unknown>
+  ): Promise<Notification> {
+    // Create notification record
+    const notification = await this.repository.createNotification({
+      userId,
+      channel,
+      status: 'pending',
+      title,
+      body,
+      data,
+    });
+
+    try {
+      switch (channel) {
+        case 'email':
+          await this.sendEmail({ to: data?.email as string, subject: title, text: body });
+          break;
+        case 'sms':
+          await this.sendSMS({ to: data?.phone as string, body });
+          break;
+        case 'push':
+          await this.sendPush({ tokens: data?.tokens as string[], title, body });
+          break;
+        case 'webhook':
+          await this.sendWebhook({ url: data?.url as string, body: { title, body, data } });
+          break;
+        case 'in_app':
+          // Just stored in database
+          break;
+      }
+
+      // Update status to sent
+      const updated = await this.repository.updateNotification(notification.id, {
+        status: 'sent',
+        sentAt: new Date(),
+      });
+
+      return updated || notification;
+    } catch (error) {
+      // Update status to failed
+      await this.repository.updateNotification(notification.id, {
+        status: 'failed',
+      });
+
+      logger.error({ error, notificationId: notification.id }, 'Failed to send notification');
+      return { ...notification, status: 'failed' };
+    }
+  }
+
+  /**
+   * Send notification to user through multiple channels
+   */
+  async sendToUser(
+    userId: string,
+    channels: NotificationChannel[],
+    title: string,
+    body: string,
+    data?: Record<string, unknown>
+  ): Promise<Notification[]> {
+    const results: Notification[] = [];
+    for (const channel of channels) {
+      const notification = await this.send(userId, channel, title, body, data);
+      results.push(notification);
+    }
+    return results;
+  }
+
+  // ==========================================
+  // EMAIL METHODS
+  // ==========================================
+
+  async sendEmail(message: EmailMessage): Promise<void> {
+    if (!this.config.email) {
+      throw new BadRequestError('Email not configured');
+    }
+
+    const { provider } = this.config.email;
+
+    switch (provider) {
+      case 'sendgrid':
+        await this.sendEmailViaSendGrid(message);
+        break;
+      case 'resend':
+        await this.sendEmailViaResend(message);
+        break;
+      case 'mailgun':
+        await this.sendEmailViaMailgun(message);
+        break;
+      case 'ses':
+        await this.sendEmailViaSES(message);
+        break;
+      default:
+        await this.sendEmailViaSMTP(message);
+    }
+
+    logger.info({ to: message.to, subject: message.subject }, 'Email sent');
+  }
+
+  private async sendEmailViaSendGrid(message: EmailMessage): Promise<void> {
+    const config = this.config.email!.sendgrid!;
+    const body = await this.renderTemplate(message);
+
+    await fetch('https://api.sendgrid.com/v3/mail/send', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        personalizations: [
+          {
+            to: Array.isArray(message.to)
+              ? message.to.map((e) => ({ email: e }))
+              : [{ email: message.to }],
+          },
+        ],
+        from: { email: this.config.email!.from },
+        subject: message.subject,
+        content: [{ type: body.html ? 'text/html' : 'text/plain', value: body.html || body.text }],
+      }),
+    });
+  }
+
+  private async sendEmailViaResend(message: EmailMessage): Promise<void> {
+    const config = this.config.email!.resend!;
+    const body = await this.renderTemplate(message);
+
+    await fetch('https://api.resend.com/emails', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        from: this.config.email!.from,
+        to: Array.isArray(message.to) ? message.to : [message.to],
+        subject: message.subject,
+        html: body.html,
+        text: body.text,
+      }),
+    });
+  }
+
+  private async sendEmailViaMailgun(message: EmailMessage): Promise<void> {
+    const config = this.config.email!.mailgun!;
+    const body = await this.renderTemplate(message);
+
+    const formData = new FormData();
+    formData.append('from', this.config.email!.from);
+    formData.append('to', Array.isArray(message.to) ? message.to.join(',') : message.to);
+    formData.append('subject', message.subject);
+    if (body.html) formData.append('html', body.html);
+    if (body.text) formData.append('text', body.text);
+
+    await fetch(`https://api.mailgun.net/v3/${config.domain}/messages`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Basic ${Buffer.from(`api:${config.apiKey}`).toString('base64')}`,
+      },
+      body: formData,
+    });
+  }
+
+  private async sendEmailViaSES(_message: EmailMessage): Promise<void> {
+    // AWS SES implementation - use @aws-sdk/client-ses in production
+    logger.debug('SES email would be sent');
+  }
+
+  private async sendEmailViaSMTP(_message: EmailMessage): Promise<void> {
+    // SMTP implementation - use nodemailer in production
+    logger.debug('SMTP email would be sent');
+  }
+
+  // ==========================================
+  // SMS METHODS
+  // ==========================================
+
+  async sendSMS(message: SMSMessage): Promise<void> {
+    if (!this.config.sms) {
+      throw new BadRequestError('SMS not configured');
+    }
+
+    const { provider } = this.config.sms;
+
+    switch (provider) {
+      case 'twilio':
+        await this.sendSMSViaTwilio(message);
+        break;
+      case 'nexmo':
+        await this.sendSMSViaNexmo(message);
+        break;
+      case 'africas_talking':
+        await this.sendSMSViaAfricasTalking(message);
+        break;
+    }
+
+    logger.info({ to: message.to }, 'SMS sent');
+  }
+
+  private async sendSMSViaTwilio(message: SMSMessage): Promise<void> {
+    const config = this.config.sms!.twilio!;
+    const recipients = Array.isArray(message.to) ? message.to : [message.to];
+
+    for (const to of recipients) {
+      await fetch(`https://api.twilio.com/2010-04-01/Accounts/${config.accountSid}/Messages.json`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Basic ${Buffer.from(`${config.accountSid}:${config.authToken}`).toString('base64')}`,
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          From: this.config.sms!.from,
+          To: to,
+          Body: message.body,
+        }),
+      });
+    }
+  }
+
+  private async sendSMSViaNexmo(message: SMSMessage): Promise<void> {
+    const config = this.config.sms!.nexmo!;
+    const recipients = Array.isArray(message.to) ? message.to : [message.to];
+
+    for (const to of recipients) {
+      await fetch('https://rest.nexmo.com/sms/json', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          api_key: config.apiKey,
+          api_secret: config.apiSecret,
+          from: this.config.sms!.from,
+          to,
+          text: message.body,
+        }),
+      });
+    }
+  }
+
+  private async sendSMSViaAfricasTalking(message: SMSMessage): Promise<void> {
+    const config = this.config.sms!.africasTalking!;
+    const recipients = Array.isArray(message.to) ? message.to.join(',') : message.to;
+
+    await fetch('https://api.africastalking.com/version1/messaging', {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        apiKey: config.apiKey,
+      },
+      body: new URLSearchParams({
+        username: config.username,
+        to: recipients,
+        message: message.body,
+        from: this.config.sms!.from,
+      }),
+    });
+  }
+
+  // ==========================================
+  // PUSH NOTIFICATION METHODS
+  // ==========================================
+
+  async sendPush(message: PushMessage): Promise<void> {
+    if (!this.config.push) {
+      throw new BadRequestError('Push notifications not configured');
+    }
+
+    const { provider } = this.config.push;
+
+    switch (provider) {
+      case 'firebase':
+        await this.sendPushViaFirebase(message);
+        break;
+      case 'onesignal':
+        await this.sendPushViaOneSignal(message);
+        break;
+    }
+
+    logger.info({ tokens: message.tokens.length }, 'Push notification sent');
+  }
+
+  private async sendPushViaFirebase(message: PushMessage): Promise<void> {
+    // Firebase Cloud Messaging - use firebase-admin in production
+    logger.debug({ message }, 'Firebase push would be sent');
+  }
+
+  private async sendPushViaOneSignal(message: PushMessage): Promise<void> {
+    const config = this.config.push!.onesignal!;
+
+    await fetch('https://onesignal.com/api/v1/notifications', {
+      method: 'POST',
+      headers: {
+        Authorization: `Basic ${config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        app_id: config.appId,
+        include_player_ids: message.tokens,
+        headings: { en: message.title },
+        contents: { en: message.body },
+        data: message.data,
+        ios_badgeType: 'SetTo',
+        ios_badgeCount: message.badge,
+      }),
+    });
+  }
+
+  // ==========================================
+  // WEBHOOK METHODS
+  // ==========================================
+
+  async sendWebhook(message: WebhookMessage): Promise<void> {
+    const config = this.config.webhook || {};
+    const method = message.method || 'POST';
+
+    const response = await fetch(message.url, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...config.defaultHeaders,
+        ...message.headers,
+      },
+      body: JSON.stringify(message.body),
+      signal: AbortSignal.timeout(config.timeout || 30000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Webhook failed: ${response.status}`);
+    }
+
+    logger.info({ url: message.url, method }, 'Webhook sent');
+  }
+
+  // ==========================================
+  // TEMPLATE METHODS
+  // ==========================================
+
+  /**
+   * Register a notification template
+   */
+  async registerTemplate(
+    template: Omit<NotificationTemplate, 'id'>
+  ): Promise<NotificationTemplate> {
+    return this.repository.createTemplate(template);
+  }
+
+  /**
+   * Get template by name
+   */
+  async getTemplate(name: string): Promise<NotificationTemplate | null> {
+    return this.repository.getTemplateByName(name);
+  }
+
+  /**
+   * Get all templates
+   */
+  async getAllTemplates(): Promise<NotificationTemplate[]> {
+    return this.repository.getAllTemplates();
+  }
+
+  private async renderTemplate(message: EmailMessage): Promise<{ text?: string; html?: string }> {
+    if (!message.template) {
+      return { text: message.text, html: message.html };
+    }
+
+    const template = await this.repository.getTemplateByName(message.template);
+    if (!template) {
+      return { text: message.text, html: message.html };
+    }
+
+    let rendered = template.body;
+    for (const [key, value] of Object.entries(message.templateData || {})) {
+      rendered = rendered.replace(new RegExp(`{{${key}}}`, 'g'), String(value));
+    }
+
+    return { html: rendered, text: rendered.replace(/<[^>]*>/g, '') };
+  }
+
+  // ==========================================
+  // IN-APP NOTIFICATION METHODS
+  // ==========================================
+
+  /**
+   * Get user's notifications
+   */
+  async getUserNotifications(
+    userId: string,
+    options?: { limit?: number; offset?: number }
+  ): Promise<Notification[]> {
+    return this.repository.getNotificationsByUserId(userId, options);
+  }
+
+  /**
+   * Get unread count for user
+   */
+  async getUnreadCount(userId: string): Promise<number> {
+    return this.repository.getUnreadCount(userId);
+  }
+
+  /**
+   * Mark notification as read
+   */
+  async markAsRead(notificationId: string): Promise<Notification | null> {
+    return this.repository.markAsRead(notificationId);
+  }
+
+  /**
+   * Mark all notifications as read for user
+   */
+  async markAllAsRead(userId: string): Promise<number> {
+    return this.repository.markAllAsRead(userId);
+  }
+
+  /**
+   * Delete old notifications (cleanup)
+   */
+  async cleanupOldNotifications(olderThanDays: number = 30): Promise<number> {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+    return this.repository.deleteOldNotifications(cutoffDate);
+  }
+}
+
+// Singleton instance
+let notificationService: NotificationService | null = null;
+
+export function getNotificationService(): NotificationService {
+  if (!notificationService) {
+    notificationService = new NotificationService();
+  }
+  return notificationService;
+}
+
+export function createNotificationService(config: NotificationConfig): NotificationService {
+  notificationService = new NotificationService(config);
+  return notificationService;
+}

package/src/modules/notification/types.ts

@@ -0,0 +1,119 @@
+export type NotificationChannel = 'email' | 'sms' | 'push' | 'in_app' | 'webhook';
+export type NotificationStatus = 'pending' | 'sent' | 'delivered' | 'failed' | 'read';
+
+export interface Notification {
+  id: string;
+  userId: string;
+  channel: NotificationChannel;
+  status: NotificationStatus;
+  title: string;
+  body: string;
+  data?: Record<string, unknown>;
+  sentAt?: Date;
+  readAt?: Date;
+  createdAt: Date;
+}
+
+export interface NotificationConfig {
+  email?: EmailConfig;
+  sms?: SMSConfig;
+  push?: PushConfig;
+  webhook?: WebhookConfig;
+}
+
+// Email configuration
+export interface EmailConfig {
+  provider: 'smtp' | 'sendgrid' | 'ses' | 'mailgun' | 'resend';
+  from: string;
+  replyTo?: string;
+  smtp?: SMTPConfig;
+  sendgrid?: { apiKey: string };
+  ses?: { region: string; accessKeyId: string; secretAccessKey: string };
+  mailgun?: { apiKey: string; domain: string };
+  resend?: { apiKey: string };
+}
+
+export interface SMTPConfig {
+  host: string;
+  port: number;
+  secure: boolean;
+  auth: {
+    user: string;
+    pass: string;
+  };
+}
+
+export interface EmailMessage {
+  to: string | string[];
+  subject: string;
+  text?: string;
+  html?: string;
+  template?: string;
+  templateData?: Record<string, unknown>;
+  attachments?: EmailAttachment[];
+  cc?: string[];
+  bcc?: string[];
+}
+
+export interface EmailAttachment {
+  filename: string;
+  content?: Buffer | string;
+  path?: string;
+  contentType?: string;
+}
+
+// SMS configuration
+export interface SMSConfig {
+  provider: 'twilio' | 'nexmo' | 'africas_talking';
+  from: string;
+  twilio?: { accountSid: string; authToken: string };
+  nexmo?: { apiKey: string; apiSecret: string };
+  africasTalking?: { username: string; apiKey: string };
+}
+
+export interface SMSMessage {
+  to: string | string[];
+  body: string;
+}
+
+// Push notification configuration
+export interface PushConfig {
+  provider: 'firebase' | 'onesignal' | 'pusher';
+  firebase?: { serviceAccount: string | object };
+  onesignal?: { appId: string; apiKey: string };
+  pusher?: { appId: string; key: string; secret: string; cluster: string };
+}
+
+export interface PushMessage {
+  tokens: string[];
+  title: string;
+  body: string;
+  data?: Record<string, string>;
+  badge?: number;
+  sound?: string;
+  imageUrl?: string;
+}
+
+// Webhook configuration
+export interface WebhookConfig {
+  defaultHeaders?: Record<string, string>;
+  timeout?: number;
+  retries?: number;
+}
+
+export interface WebhookMessage {
+  url: string;
+  method?: 'POST' | 'PUT' | 'PATCH';
+  headers?: Record<string, string>;
+  body: unknown;
+}
+
+// Template support
+export interface NotificationTemplate {
+  id: string;
+  name: string;
+  channel: NotificationChannel;
+  subject?: string;
+  body: string;
+  variables: string[];
+}

package/src/modules/oauth/index.ts

@@ -0,0 +1,20 @@
+export { OAuthService, getOAuthService, createOAuthService } from './oauth.service.js';
+export { registerOAuthRoutes } from './oauth.routes.js';
+export { GoogleOAuthProvider } from './providers/google.provider.js';
+export { FacebookOAuthProvider } from './providers/facebook.provider.js';
+export { GitHubOAuthProvider } from './providers/github.provider.js';
+export { TwitterOAuthProvider } from './providers/twitter.provider.js';
+export { AppleOAuthProvider } from './providers/apple.provider.js';
+export type {
+  OAuthConfig,
+  OAuthProvider,
+  OAuthUser,
+  OAuthTokens,
+  OAuthState,
+  LinkedAccount,
+  GoogleOAuthConfig,
+  FacebookOAuthConfig,
+  GitHubOAuthConfig,
+  TwitterOAuthConfig,
+  AppleOAuthConfig,
+} from './types.js';