dubs-server 1.0.0

package/routes/deviceRoutes.js

@@ -0,0 +1,214 @@
+/**
+ * 📱 Device Settings API Routes
+ * 
+ * Public endpoints for device-level settings (no authentication required)
+ * Used for cross-browser state like "Add to Home Screen" banner dismissal
+ */
+
+const express = require('express');
+const router = express.Router();
+const { pool } = require('../services/db');
+
+// Initialize device_settings table
+async function initializeDeviceTable() {
+  if (!process.env.DATABASE_URL) {
+    console.log('⚠️  Device settings table skipped: DATABASE_URL not set');
+    return;
+  }
+
+  try {
+    // Create table if it doesn't exist
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS device_settings (
+        id SERIAL PRIMARY KEY,
+        device_id VARCHAR(255) UNIQUE NOT NULL,
+        wallet_address VARCHAR(44),
+        dismissed_a2hs BOOLEAN DEFAULT false,
+        platform VARCHAR(50),
+        user_agent TEXT,
+        last_seen TIMESTAMP DEFAULT NOW(),
+        created_at TIMESTAMP DEFAULT NOW()
+      );
+    `);
+
+    // Add wallet_address column if it doesn't exist (migration for existing tables)
+    await pool.query(`
+      DO $$ 
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM information_schema.columns 
+          WHERE table_name = 'device_settings' 
+          AND column_name = 'wallet_address'
+        ) THEN
+          ALTER TABLE device_settings ADD COLUMN wallet_address VARCHAR(44);
+          RAISE NOTICE 'Added wallet_address column to device_settings';
+        END IF;
+      END $$;
+    `);
+
+    // Create indexes
+    await pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_device_id ON device_settings(device_id);
+      CREATE INDEX IF NOT EXISTS idx_wallet_address ON device_settings(wallet_address);
+    `);
+
+    console.log('✅ Device settings table ready');
+  } catch (error) {
+    console.error('❌ Failed to initialize device_settings table:', error);
+  }
+}
+
+initializeDeviceTable();
+
+/**
+ * GET /api/device/check-dismissal
+ * Check if A2HS was dismissed for this wallet
+ * Query params: walletAddress (REQUIRED)
+ */
+router.get('/check-dismissal', async (req, res) => {
+  try {
+    const { walletAddress } = req.query;
+    
+    if (!walletAddress) {
+      return res.status(400).json({ error: 'walletAddress is required' });
+    }
+    
+    const result = await pool.query(
+      'SELECT * FROM device_settings WHERE wallet_address = $1 AND dismissed_a2hs = true',
+      [walletAddress]
+    );
+    
+    if (result.rows.length > 0) {
+      return res.json({
+        dismissedA2HS: true,
+        lastSeen: result.rows[0].last_seen,
+      });
+    }
+    
+    res.json({
+      dismissedA2HS: false,
+      lastSeen: null,
+    });
+  } catch (error) {
+    console.error('[DeviceRoutes] Error fetching device settings:', error);
+    res.status(500).json({ error: 'Failed to fetch device settings' });
+  }
+});
+
+/**
+ * POST /api/device/dismiss-a2hs
+ * Mark "Add to Home Screen" banner as dismissed for this wallet
+ * 
+ * Body: {
+ *   walletAddress: string (REQUIRED),
+ *   platform?: string (ios/android),
+ *   userAgent?: string
+ * }
+ */
+router.post('/dismiss-a2hs', async (req, res) => {
+  try {
+    const { walletAddress, platform, userAgent } = req.body;
+    
+    if (!walletAddress) {
+      return res.status(400).json({ error: 'walletAddress is required' });
+    }
+
+    // Upsert: Insert or update if exists
+    await pool.query(`
+      INSERT INTO device_settings (device_id, wallet_address, dismissed_a2hs, platform, user_agent, last_seen)
+      VALUES ($1, $2, true, $3, $4, NOW())
+      ON CONFLICT (device_id)
+      DO UPDATE SET
+        dismissed_a2hs = true,
+        platform = COALESCE($3, device_settings.platform),
+        user_agent = COALESCE($4, device_settings.user_agent),
+        last_seen = NOW()
+    `, [`wallet_${walletAddress}`, walletAddress, platform, userAgent]);
+
+    console.log(`[DeviceRoutes] ✅ A2HS dismissed for wallet: ${walletAddress.slice(0, 8)}...`);
+
+    res.json({ 
+      success: true,
+      dismissedA2HS: true
+    });
+  } catch (error) {
+    console.error('[DeviceRoutes] ❌ Error dismissing A2HS:', error);
+    res.status(500).json({ error: 'Failed to save dismissal' });
+  }
+});
+
+/**
+ * POST /api/device/link-wallet
+ * Link a wallet address to the current device (by IP)
+ * Called when user authenticates - links their wallet to any IP-based dismissals
+ * 
+ * Body: {
+ *   walletAddress: string
+ * }
+ */
+router.post('/link-wallet', async (req, res) => {
+  try {
+    const { walletAddress } = req.body;
+    
+    if (!walletAddress) {
+      return res.status(400).json({ error: 'walletAddress is required' });
+    }
+
+    const ipAddress = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || 
+                      req.headers['x-real-ip'] || 
+                      req.connection.remoteAddress || 
+                      req.socket.remoteAddress;
+
+    if (!ipAddress) {
+      return res.status(400).json({ error: 'Unable to determine IP address' });
+    }
+
+    const deviceId = `ip_${ipAddress}`;
+
+    // Update the current IP's record with the wallet address
+    await pool.query(`
+      UPDATE device_settings 
+      SET wallet_address = $1, last_seen = NOW()
+      WHERE device_id = $2
+    `, [walletAddress, deviceId]);
+
+    console.log(`[DeviceRoutes] ✅ Linked wallet ${walletAddress.slice(0, 8)}... to IP: ${ipAddress}`);
+
+    res.json({ 
+      success: true,
+      walletAddress,
+      deviceId
+    });
+  } catch (error) {
+    console.error('[DeviceRoutes] Error linking wallet:', error);
+    res.status(500).json({ error: 'Failed to link wallet' });
+  }
+});
+
+/**
+ * DELETE /api/device/:deviceId/dismiss-a2hs
+ * Reset dismissal (for testing or user request)
+ */
+router.delete('/:deviceId/dismiss-a2hs', async (req, res) => {
+  try {
+    const { deviceId } = req.params;
+
+    await pool.query(
+      'UPDATE device_settings SET dismissed_a2hs = false, last_seen = NOW() WHERE device_id = $1',
+      [deviceId]
+    );
+
+    console.log(`[DeviceRoutes] ✅ A2HS dismissal reset for device: ${deviceId.slice(0, 8)}...`);
+
+    res.json({ 
+      success: true,
+      deviceId,
+      dismissedA2HS: false
+    });
+  } catch (error) {
+    console.error('[DeviceRoutes] Error resetting dismissal:', error);
+    res.status(500).json({ error: 'Failed to reset dismissal' });
+  }
+});
+
+module.exports = router;

package/routes/dmRoutes.js

@@ -0,0 +1,167 @@
+/**
+ * 💬 Direct Message Routes
+ * 
+ * REST API endpoints for direct messages
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/authenticate');
+
+// Will be injected from server.js
+let dmService = null;
+
+/**
+ * Initialize routes with dependencies
+ */
+function initializeDMRoutes(dmServiceInstance) {
+  dmService = dmServiceInstance;
+  return router;
+}
+
+/**
+ * GET /dm/conversations
+ * Get all conversations for the current user (inbox)
+ */
+router.get('/conversations', authenticate, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const limit = parseInt(req.query.limit) || 20;
+
+    const conversations = await dmService.getConversations(userId, limit);
+    res.json({ conversations });
+  } catch (error) {
+    console.error('[DM Routes] Error getting conversations:', error);
+    res.status(500).json({ error: 'Failed to get conversations' });
+  }
+});
+
+/**
+ * GET /dm/conversation/:walletAddress
+ * Get conversation history with a specific user
+ */
+router.get('/conversation/:walletAddress', authenticate, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const { walletAddress } = req.params;
+    const limit = parseInt(req.query.limit) || 50;
+    const beforeId = req.query.beforeId ? parseInt(req.query.beforeId) : null;
+
+    // Get other user's ID from wallet
+    const otherUser = await dmService.getUserByWallet(walletAddress);
+    if (!otherUser) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    const messages = await dmService.getConversation(userId, otherUser.id, limit, beforeId);
+    
+    // Mark messages as read
+    await dmService.markAsRead(userId, otherUser.id);
+
+    res.json({ 
+      messages,
+      otherUser: {
+        id: otherUser.id,
+        username: otherUser.username,
+        avatar: otherUser.avatar,
+        walletAddress: otherUser.walletAddress,
+      }
+    });
+  } catch (error) {
+    console.error('[DM Routes] Error getting conversation:', error);
+    res.status(500).json({ error: 'Failed to get conversation' });
+  }
+});
+
+/**
+ * POST /dm/send
+ * Send a direct message
+ */
+router.post('/send', authenticate, async (req, res) => {
+  try {
+    const senderId = req.user.userId;
+    const { recipientWallet, message } = req.body;
+
+    if (!recipientWallet || !message) {
+      return res.status(400).json({ error: 'recipientWallet and message are required' });
+    }
+
+    // Get recipient's ID from wallet
+    const recipient = await dmService.getUserByWallet(recipientWallet);
+    if (!recipient) {
+      return res.status(404).json({ error: 'Recipient not found' });
+    }
+
+    if (recipient.id === senderId) {
+      return res.status(400).json({ error: 'Cannot send message to yourself' });
+    }
+
+    const dm = await dmService.sendMessage(senderId, recipient.id, message);
+    res.json({ message: dm });
+  } catch (error) {
+    console.error('[DM Routes] Error sending message:', error);
+    res.status(500).json({ error: error.message || 'Failed to send message' });
+  }
+});
+
+/**
+ * POST /dm/read/:walletAddress
+ * Mark all messages from a user as read
+ */
+router.post('/read/:walletAddress', authenticate, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const { walletAddress } = req.params;
+
+    const otherUser = await dmService.getUserByWallet(walletAddress);
+    if (!otherUser) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    const count = await dmService.markAsRead(userId, otherUser.id);
+    res.json({ markedRead: count });
+  } catch (error) {
+    console.error('[DM Routes] Error marking as read:', error);
+    res.status(500).json({ error: 'Failed to mark as read' });
+  }
+});
+
+/**
+ * GET /dm/unread
+ * Get unread DM count
+ */
+router.get('/unread', authenticate, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const count = await dmService.getUnreadCount(userId);
+    res.json({ unreadCount: count });
+  } catch (error) {
+    console.error('[DM Routes] Error getting unread count:', error);
+    res.status(500).json({ error: 'Failed to get unread count' });
+  }
+});
+
+/**
+ * DELETE /dm/conversation/:walletAddress
+ * Delete a conversation (soft delete for current user only)
+ */
+router.delete('/conversation/:walletAddress', authenticate, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const { walletAddress } = req.params;
+
+    const otherUser = await dmService.getUserByWallet(walletAddress);
+    if (!otherUser) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    await dmService.deleteConversation(userId, otherUser.id);
+    res.json({ success: true });
+  } catch (error) {
+    console.error('[DM Routes] Error deleting conversation:', error);
+    res.status(500).json({ error: 'Failed to delete conversation' });
+  }
+});
+
+module.exports = { initializeDMRoutes, router };
+