dubs-server 1.0.0

package/services/directMessageService.js

@@ -0,0 +1,389 @@
+/**
+ * 💬 Direct Message Service
+ * 
+ * Private 1:1 messaging between users
+ */
+
+const { pool } = require('./db'); // Shared database pool
+const { forwardChatNotification } = require('./telegramNotifications');
+
+class DirectMessageService {
+  constructor() {
+    // Use shared pool from services/db.js
+    this.pool = pool;
+    
+    this.initialized = false;
+  }
+
+  async initializeTable() {
+    try {
+      await this.pool.query(`
+        -- Direct messages table
+        CREATE TABLE IF NOT EXISTS direct_messages (
+          id SERIAL PRIMARY KEY,
+          sender_id INTEGER REFERENCES users(id) ON DELETE CASCADE NOT NULL,
+          recipient_id INTEGER REFERENCES users(id) ON DELETE CASCADE NOT NULL,
+          message TEXT NOT NULL,
+          metadata JSONB DEFAULT NULL,
+          read BOOLEAN DEFAULT FALSE,
+          deleted_by_sender BOOLEAN DEFAULT FALSE,
+          deleted_by_recipient BOOLEAN DEFAULT FALSE,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        -- Indexes for fast queries
+        CREATE INDEX IF NOT EXISTS idx_dm_sender ON direct_messages(sender_id);
+        CREATE INDEX IF NOT EXISTS idx_dm_recipient ON direct_messages(recipient_id);
+        CREATE INDEX IF NOT EXISTS idx_dm_conversation ON direct_messages(
+          LEAST(sender_id, recipient_id), 
+          GREATEST(sender_id, recipient_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_dm_created ON direct_messages(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_dm_unread ON direct_messages(recipient_id, read) WHERE read = false;
+      `);
+      
+      // Add metadata column if it doesn't exist (for existing tables)
+      await this.pool.query(`
+        ALTER TABLE direct_messages 
+        ADD COLUMN IF NOT EXISTS metadata JSONB DEFAULT NULL
+      `).catch(() => {});
+
+      // NOTE: Notification type constraint is now managed by migration file:
+      // scripts/migrations/004_add_whats_new_notification_type.sql
+      // Do not update the constraint here - run the migration instead.
+
+      this.initialized = true;
+      console.log('✅ Direct messages table initialized');
+    } catch (error) {
+      console.error('❌ Failed to initialize DM table:', error.message);
+    }
+  }
+
+  /**
+   * Generate a unique conversation ID for two users (always sorted)
+   */
+  getConversationKey(userId1, userId2) {
+    return [Math.min(userId1, userId2), Math.max(userId1, userId2)].join('_');
+  }
+
+  /**
+   * Send a direct message
+   * @param {number} senderId - Sender user ID
+   * @param {number} recipientId - Recipient user ID
+   * @param {string} message - Message text
+   * @param {object} metadata - Optional metadata (gameInvite, etc.)
+   */
+  async sendMessage(senderId, recipientId, message, metadata = null) {
+    try {
+      // Validate message
+      const sanitized = message.trim().substring(0, 1000);
+      if (!sanitized || sanitized.length === 0) {
+        throw new Error('Message cannot be empty');
+      }
+
+      // Check if recipient has blocked sender
+      const blockCheck = await this.pool.query(
+        `SELECT 1 FROM user_relationships 
+         WHERE user_id = $1 AND target_user_id = $2 AND relationship_type = 'block'`,
+        [recipientId, senderId]
+      );
+
+      if (blockCheck.rows.length > 0) {
+        throw new Error('Cannot send message to this user');
+      }
+
+      // Insert message with optional metadata
+      const result = await this.pool.query(
+        `INSERT INTO direct_messages (sender_id, recipient_id, message, metadata, created_at)
+         VALUES ($1, $2, $3, $4, NOW())
+         RETURNING *`,
+        [senderId, recipientId, sanitized, metadata ? JSON.stringify(metadata) : null]
+      );
+
+      const dm = result.rows[0];
+
+      // Get sender info for response
+      const senderInfo = await this.pool.query(
+        'SELECT username, avatar, wallet_address FROM users WHERE id = $1',
+        [senderId]
+      );
+      
+      const senderUsername = senderInfo.rows[0]?.username || 'Someone';
+
+      // Check if this is a game invite
+      const isGameInvite = metadata?.gameInvite != null;
+      
+      if (isGameInvite) {
+        const gameInvite = metadata.gameInvite;
+        // Create game_invite notification for recipient
+        await this.pool.query(
+          `INSERT INTO chat_notifications (user_id, sender_user_id, notification_type, notification_data, created_at)
+           VALUES ($1, $2, 'game_invite', $3, NOW())`,
+          [recipientId, senderId, JSON.stringify({ 
+            messageId: dm.id, 
+            gameInvite,
+            preview: sanitized.substring(0, 50)
+          })]
+        );
+        
+        // Forward to Telegram with game invite details
+        const gameDetails = `🎱 *${gameInvite.title || 'Pool Room'}*\n💰 Buy-in: ${gameInvite.buyIn || 0.25} SOL`;
+        forwardChatNotification(this.pool, recipientId, 'game_invite', senderUsername, gameDetails)
+          .catch(err => console.error('[DM] Error forwarding game invite to Telegram:', err.message));
+          
+        console.log(`🎮 Game invite notification sent from ${senderUsername} to user ${recipientId}`);
+      } else {
+        // Create standard dm_message notification
+        await this.pool.query(
+          `INSERT INTO chat_notifications (user_id, sender_user_id, notification_type, notification_data, created_at)
+           VALUES ($1, $2, 'dm_message', $3, NOW())`,
+          [recipientId, senderId, JSON.stringify({ messageId: dm.id, preview: sanitized.substring(0, 50) })]
+        );
+
+        // Forward to Telegram if connected
+        forwardChatNotification(this.pool, recipientId, 'dm_message', senderUsername, sanitized.substring(0, 100))
+          .catch(err => console.error('[DM] Error forwarding to Telegram:', err.message));
+      }
+
+      console.log(`💬 DM sent from ${senderId} to ${recipientId}${metadata?.gameInvite ? ' (with game invite)' : ''}`);
+
+      // Parse metadata if it was stored
+      const parsedMetadata = dm.metadata ? (typeof dm.metadata === 'string' ? JSON.parse(dm.metadata) : dm.metadata) : null;
+
+      return {
+        id: dm.id,
+        senderId: dm.sender_id,
+        recipientId: dm.recipient_id,
+        senderUsername: senderInfo.rows[0]?.username || 'Unknown',
+        senderAvatar: senderInfo.rows[0]?.avatar || null,
+        senderWallet: senderInfo.rows[0]?.wallet_address || '',
+        message: dm.message,
+        read: dm.read,
+        createdAt: dm.created_at,
+        isOwn: true,
+        gameInvite: parsedMetadata?.gameInvite || null,
+      };
+    } catch (error) {
+      console.error('[DM] Error sending message:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get conversation history between two users
+   */
+  async getConversation(userId1, userId2, limit = 50, beforeId = null) {
+    try {
+      let query = `
+        SELECT 
+          dm.*,
+          sender.username as sender_username,
+          sender.avatar as sender_avatar,
+          sender.wallet_address as sender_wallet
+        FROM direct_messages dm
+        JOIN users sender ON dm.sender_id = sender.id
+        WHERE (
+          (dm.sender_id = $1 AND dm.recipient_id = $2 AND dm.deleted_by_sender = false)
+          OR 
+          (dm.sender_id = $2 AND dm.recipient_id = $1 AND dm.deleted_by_recipient = false)
+        )
+      `;
+      
+      const params = [userId1, userId2];
+      
+      if (beforeId) {
+        query += ` AND dm.id < $3`;
+        params.push(beforeId);
+      }
+      
+      query += ` ORDER BY dm.created_at DESC LIMIT $${params.length + 1}`;
+      params.push(limit);
+
+      const result = await this.pool.query(query, params);
+
+      return result.rows.map(row => {
+        // Parse metadata if present
+        const metadata = row.metadata ? (typeof row.metadata === 'string' ? JSON.parse(row.metadata) : row.metadata) : null;
+        
+        return {
+          id: row.id,
+          senderId: row.sender_id,
+          recipientId: row.recipient_id,
+          senderUsername: row.sender_username,
+          senderAvatar: row.sender_avatar,
+          senderWallet: row.sender_wallet,
+          message: row.message,
+          read: row.read,
+          createdAt: row.created_at,
+          isOwn: parseInt(row.sender_id) === parseInt(userId1),
+          gameInvite: metadata?.gameInvite || null,
+        };
+      }).reverse(); // Reverse so oldest is first
+    } catch (error) {
+      console.error('[DM] Error getting conversation:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get all conversations for a user (for inbox view)
+   */
+  async getConversations(userId, limit = 20) {
+    try {
+      // Get the latest message from each conversation
+      const result = await this.pool.query(
+        `WITH latest_messages AS (
+          SELECT DISTINCT ON (
+            LEAST(sender_id, recipient_id), 
+            GREATEST(sender_id, recipient_id)
+          )
+          id,
+          sender_id,
+          recipient_id,
+          message,
+          read,
+          created_at,
+          CASE 
+            WHEN sender_id = $1 THEN recipient_id
+            ELSE sender_id
+          END as other_user_id
+          FROM direct_messages
+          WHERE (sender_id = $1 AND deleted_by_sender = false)
+             OR (recipient_id = $1 AND deleted_by_recipient = false)
+          ORDER BY 
+            LEAST(sender_id, recipient_id),
+            GREATEST(sender_id, recipient_id),
+            created_at DESC
+        )
+        SELECT 
+          lm.*,
+          u.username as other_username,
+          u.avatar as other_avatar,
+          u.wallet_address as other_wallet,
+          (SELECT COUNT(*) FROM direct_messages 
+           WHERE sender_id = lm.other_user_id 
+           AND recipient_id = $1 
+           AND read = false) as unread_count
+        FROM latest_messages lm
+        JOIN users u ON lm.other_user_id = u.id
+        ORDER BY lm.created_at DESC
+        LIMIT $2`,
+        [userId, limit]
+      );
+
+      return result.rows.map(row => ({
+        otherUserId: row.other_user_id,
+        otherUsername: row.other_username,
+        otherAvatar: row.other_avatar,
+        otherWallet: row.other_wallet,
+        lastMessage: {
+          id: row.id,
+          message: row.message,
+          senderId: row.sender_id,
+          createdAt: row.created_at,
+          isOwn: row.sender_id === userId,
+        },
+        unreadCount: parseInt(row.unread_count),
+      }));
+    } catch (error) {
+      console.error('[DM] Error getting conversations:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Mark messages as read
+   */
+  async markAsRead(userId, senderId) {
+    try {
+      const result = await this.pool.query(
+        `UPDATE direct_messages 
+         SET read = true
+         WHERE recipient_id = $1 AND sender_id = $2 AND read = false
+         RETURNING id`,
+        [userId, senderId]
+      );
+      
+      console.log(`[DM] Marked ${result.rows.length} messages as read`);
+      return result.rows.length;
+    } catch (error) {
+      console.error('[DM] Error marking as read:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Get unread DM count for a user
+   */
+  async getUnreadCount(userId) {
+    try {
+      const result = await this.pool.query(
+        `SELECT COUNT(DISTINCT sender_id) as count
+         FROM direct_messages
+         WHERE recipient_id = $1 AND read = false`,
+        [userId]
+      );
+      
+      return parseInt(result.rows[0].count);
+    } catch (error) {
+      console.error('[DM] Error getting unread count:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Delete a conversation (soft delete for one user)
+   */
+  async deleteConversation(userId, otherUserId) {
+    try {
+      // Mark messages as deleted for this user
+      await this.pool.query(
+        `UPDATE direct_messages 
+         SET deleted_by_sender = true
+         WHERE sender_id = $1 AND recipient_id = $2`,
+        [userId, otherUserId]
+      );
+
+      await this.pool.query(
+        `UPDATE direct_messages 
+         SET deleted_by_recipient = true
+         WHERE sender_id = $2 AND recipient_id = $1`,
+        [userId, otherUserId]
+      );
+
+      console.log(`[DM] Conversation deleted for user ${userId}`);
+      return true;
+    } catch (error) {
+      console.error('[DM] Error deleting conversation:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get user info by wallet address
+   */
+  async getUserByWallet(walletAddress) {
+    try {
+      const result = await this.pool.query(
+        'SELECT id, username, avatar, wallet_address FROM users WHERE wallet_address = $1',
+        [walletAddress]
+      );
+      
+      if (result.rows.length > 0) {
+        return {
+          id: result.rows[0].id,
+          username: result.rows[0].username,
+          avatar: result.rows[0].avatar,
+          walletAddress: result.rows[0].wallet_address,
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error('[DM] Error getting user by wallet:', error);
+      return null;
+    }
+  }
+}
+
+module.exports = DirectMessageService;
+

package/services/discordNotifications.js

@@ -0,0 +1,160 @@
+// Discord Notification Service
+// Posts new game announcements to a Discord channel via webhook
+
+const axios = require('axios');
+const urlHelper = require('../utils/urlHelper');
+
+const DISCORD_NEW_GAME_WEBHOOK_URL = process.env.DISCORD_NEW_GAME_WEBHOOK_URL;
+
+// Sport/league to emoji mapping
+const SPORT_EMOJIS = {
+  // Leagues
+  'NBA': '🏀',
+  'NFL': '🏈',
+  'NHL': '🏒',
+  'MLB': '⚾',
+  'MLS': '⚽',
+  'EPL': '⚽',
+  'English Premier League': '⚽',
+  'Premier League': '⚽',
+  'La Liga': '⚽',
+  'Serie A': '⚽',
+  'Bundesliga': '⚽',
+  'UEFA Champions League': '⚽',
+  'NCAA': '🏈',
+  // Sports (fallback)
+  'Basketball': '🏀',
+  'Football': '🏈',
+  'Hockey': '🏒',
+  'Baseball': '⚾',
+  'Soccer': '⚽',
+  'default': '🎮'
+};
+
+/**
+ * Get emoji for a sport/league
+ */
+function getSportEmoji(sportsEvent) {
+  if (!sportsEvent) return SPORT_EMOJIS.default;
+
+  const league = sportsEvent.strLeague || '';
+  const sport = sportsEvent.strSport || '';
+
+  // Check league first
+  if (SPORT_EMOJIS[league]) return SPORT_EMOJIS[league];
+
+  // Check sport
+  if (SPORT_EMOJIS[sport]) return SPORT_EMOJIS[sport];
+
+  return SPORT_EMOJIS.default;
+}
+
+/**
+ * Post a new game announcement to Discord
+ * @param {object} gameData - The game data from the save endpoint
+ * @returns {Promise<boolean>} - Success status
+ */
+async function notifyNewGame(gameData) {
+  if (!DISCORD_NEW_GAME_WEBHOOK_URL) {
+    console.log('[Discord] ⚠️ DISCORD_NEW_GAME_WEBHOOK_URL not set - skipping notification');
+    return false;
+  }
+
+  try {
+    const { gameId, title, buyIn, sportsEvent, creatorUsername, matchupImageUrl } = gameData;
+
+    // Extract team and league info
+    const homeTeam = sportsEvent?.strHomeTeam || 'TBD';
+    const awayTeam = sportsEvent?.strAwayTeam || 'TBD';
+    const league = sportsEvent?.strLeague || sportsEvent?.strSport || 'Sports';
+    // Use matchup image if provided, otherwise fall back to event thumbnail
+    const eventThumb = matchupImageUrl || sportsEvent?.strThumb || null;
+    const emoji = getSportEmoji(sportsEvent);
+
+    // Format lock time (betting closes 10 minutes before game start)
+    let lockTimeStr = 'TBD';
+    if (sportsEvent?.strTimestamp) {
+      const gameStartDate = new Date(sportsEvent.strTimestamp + 'Z');
+      const bettingClosesAt = new Date(gameStartDate.getTime() - 10 * 60 * 1000); // 10 minutes before
+      lockTimeStr = bettingClosesAt.toLocaleString('en-US', {
+        weekday: 'short',
+        month: 'short',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+        timeZoneName: 'short'
+      });
+    }
+
+    // Get proper game URL using urlHelper
+    const gameUrl = urlHelper.getGameShareUrl(gameId);
+
+    // Build Discord embed
+    const embed = {
+      title: `${emoji} New Game Created!`,
+      description: `**${awayTeam}** @ **${homeTeam}**`,
+      color: 0x5865F2,
+      fields: [
+        {
+          name: '💰 Buy-in',
+          value: `${buyIn} SOL`,
+          inline: true
+        },
+        {
+          name: '🏆 League',
+          value: league,
+          inline: true
+        },
+        {
+          name: '🔒 Betting Closes',
+          value: lockTimeStr,
+          inline: true
+        },
+        {
+          name: '👤 Created By',
+          value: creatorUsername || 'Anonymous',
+          inline: true
+        },
+        {
+          name: '🔗 Join Game',
+          value: `[Click here to join](${gameUrl})`,
+          inline: false
+        }
+      ],
+      url: gameUrl,
+      footer: {
+        text: 'Dubs - Bet with friends on Solana'
+      },
+      timestamp: new Date().toISOString()
+    };
+
+    // Add event thumbnail if available
+    if (eventThumb) {
+      embed.image = { url: eventThumb };
+    }
+
+    const payload = { embeds: [embed] };
+
+    console.log(`[Discord] 🚀 Posting new game ${gameId} to Discord...`);
+    const response = await axios.post(DISCORD_NEW_GAME_WEBHOOK_URL, payload);
+
+    if (response.status === 204 || response.status === 200) {
+      console.log(`[Discord] ✅ Successfully posted game ${gameId} to Discord`);
+      return true;
+    }
+
+    console.log(`[Discord] ⚠️ Unexpected response status: ${response.status}`);
+    return false;
+  } catch (error) {
+    if (error.response) {
+      console.error(`[Discord] ❌ Webhook error (${error.response.status}):`, error.response.data);
+    } else {
+      console.error('[Discord] ❌ Failed to post to Discord:', error.message);
+    }
+    return false;
+  }
+}
+
+module.exports = {
+  notifyNewGame
+};