@xtr-dev/rondevu-server 0.0.1 → 0.1.1

package/src/storage/sqlite.ts

@@ -1,9 +1,9 @@
 import Database from 'better-sqlite3';
-import { randomUUID } from 'crypto';
-import { Storage, Session } from './types.ts';
+import { Storage, Offer, IceCandidate, CreateOfferRequest, TopicInfo } from './types.ts';
+import { generateOfferHash } from './hash-id.ts';
 
 /**
- * SQLite storage adapter for session management
+ * SQLite storage adapter for topic-based offer management
  * Supports both file-based and in-memory databases
  */
 export class SQLiteStorage implements Storage {
@@ -16,243 +16,388 @@ export class SQLiteStorage implements Storage {
   constructor(path: string = ':memory:') {
     this.db = new Database(path);
     this.initializeDatabase();
-    this.startCleanupInterval();
   }
 
   /**
-   * Initializes database schema
+   * Initializes database schema with new topic-based structure
    */
   private initializeDatabase(): void {
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        code TEXT PRIMARY KEY,
-        origin TEXT NOT NULL,
-        topic TEXT NOT NULL,
-        info TEXT NOT NULL CHECK(length(info) <= 1024),
-        offer TEXT NOT NULL,
-        answer TEXT,
-        offer_candidates TEXT NOT NULL DEFAULT '[]',
-        answer_candidates TEXT NOT NULL DEFAULT '[]',
+      CREATE TABLE IF NOT EXISTS offers (
+        id TEXT PRIMARY KEY,
+        peer_id TEXT NOT NULL,
+        sdp TEXT NOT NULL,
         created_at INTEGER NOT NULL,
-        expires_at INTEGER NOT NULL
+        expires_at INTEGER NOT NULL,
+        last_seen INTEGER NOT NULL,
+        secret TEXT,
+        answerer_peer_id TEXT,
+        answer_sdp TEXT,
+        answered_at INTEGER
       );
 
-      CREATE INDEX IF NOT EXISTS idx_expires_at ON sessions(expires_at);
-      CREATE INDEX IF NOT EXISTS idx_origin_topic ON sessions(origin, topic);
-      CREATE INDEX IF NOT EXISTS idx_origin_topic_expires ON sessions(origin, topic, expires_at);
-    `);
-  }
+      CREATE INDEX IF NOT EXISTS idx_offers_peer ON offers(peer_id);
+      CREATE INDEX IF NOT EXISTS idx_offers_expires ON offers(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_offers_last_seen ON offers(last_seen);
+      CREATE INDEX IF NOT EXISTS idx_offers_answerer ON offers(answerer_peer_id);
 
-  /**
-   * Starts periodic cleanup of expired sessions
-   */
-  private startCleanupInterval(): void {
-    // Run cleanup every minute
-    setInterval(() => {
-      this.cleanup().catch(err => {
-        console.error('Cleanup error:', err);
-      });
-    }, 60000);
-  }
+      CREATE TABLE IF NOT EXISTS offer_topics (
+        offer_id TEXT NOT NULL,
+        topic TEXT NOT NULL,
+        PRIMARY KEY (offer_id, topic),
+        FOREIGN KEY (offer_id) REFERENCES offers(id) ON DELETE CASCADE
+      );
 
-  /**
-   * Generates a unique code using UUID
-   */
-  private generateCode(): string {
-    return randomUUID();
-  }
+      CREATE INDEX IF NOT EXISTS idx_topics_topic ON offer_topics(topic);
+      CREATE INDEX IF NOT EXISTS idx_topics_offer ON offer_topics(offer_id);
 
-  async createSession(origin: string, topic: string, info: string, offer: string, expiresAt: number): Promise<string> {
-    // Validate info length
-    if (info.length > 1024) {
-      throw new Error('Info string must be 1024 characters or less');
-    }
-
-    let code: string;
-    let attempts = 0;
-    const maxAttempts = 10;
+      CREATE TABLE IF NOT EXISTS ice_candidates (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        offer_id TEXT NOT NULL,
+        peer_id TEXT NOT NULL,
+        role TEXT NOT NULL CHECK(role IN ('offerer', 'answerer')),
+        candidate TEXT NOT NULL, -- JSON: RTCIceCandidateInit object
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (offer_id) REFERENCES offers(id) ON DELETE CASCADE
+      );
 
-    // Try to generate a unique code
-    do {
-      code = this.generateCode();
-      attempts++;
+      CREATE INDEX IF NOT EXISTS idx_ice_offer ON ice_candidates(offer_id);
+      CREATE INDEX IF NOT EXISTS idx_ice_peer ON ice_candidates(peer_id);
+      CREATE INDEX IF NOT EXISTS idx_ice_created ON ice_candidates(created_at);
+    `);
 
-      if (attempts > maxAttempts) {
-        throw new Error('Failed to generate unique session code');
-      }
+    // Enable foreign keys
+    this.db.pragma('foreign_keys = ON');
+  }
 
-      try {
-        const stmt = this.db.prepare(`
-          INSERT INTO sessions (code, origin, topic, info, offer, created_at, expires_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
-        `);
-
-        stmt.run(code, origin, topic, info, offer, Date.now(), expiresAt);
-        break;
-      } catch (err: any) {
-        // If unique constraint failed, try again
-        if (err.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
-          continue;
+  async createOffers(offers: CreateOfferRequest[]): Promise<Offer[]> {
+    const created: Offer[] = [];
+
+    // Generate hash-based IDs for all offers first
+    const offersWithIds = await Promise.all(
+      offers.map(async (offer) => ({
+        ...offer,
+        id: offer.id || await generateOfferHash(offer.sdp, offer.topics),
+      }))
+    );
+
+    // Use transaction for atomic creation
+    const transaction = this.db.transaction((offersWithIds: (CreateOfferRequest & { id: string })[]) => {
+      const offerStmt = this.db.prepare(`
+        INSERT INTO offers (id, peer_id, sdp, created_at, expires_at, last_seen, secret)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+
+      const topicStmt = this.db.prepare(`
+        INSERT INTO offer_topics (offer_id, topic)
+        VALUES (?, ?)
+      `);
+
+      for (const offer of offersWithIds) {
+        const now = Date.now();
+
+        // Insert offer
+        offerStmt.run(
+          offer.id,
+          offer.peerId,
+          offer.sdp,
+          now,
+          offer.expiresAt,
+          now,
+          offer.secret || null
+        );
+
+        // Insert topics
+        for (const topic of offer.topics) {
+          topicStmt.run(offer.id, topic);
         }
-        throw err;
+
+        created.push({
+          id: offer.id,
+          peerId: offer.peerId,
+          sdp: offer.sdp,
+          topics: offer.topics,
+          createdAt: now,
+          expiresAt: offer.expiresAt,
+          lastSeen: now,
+          secret: offer.secret,
+        });
       }
-    } while (true);
+    });
 
-    return code;
+    transaction(offersWithIds);
+    return created;
   }
 
-  async listSessionsByTopic(origin: string, topic: string): Promise<Session[]> {
-    const stmt = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE origin = ? AND topic = ? AND expires_at > ? AND answer IS NULL
-      ORDER BY created_at DESC
-    `);
+  async getOffersByTopic(topic: string, excludePeerIds?: string[]): Promise<Offer[]> {
+    let query = `
+      SELECT DISTINCT o.*
+      FROM offers o
+      INNER JOIN offer_topics ot ON o.id = ot.offer_id
+      WHERE ot.topic = ? AND o.expires_at > ?
+    `;
 
-    const rows = stmt.all(origin, topic, Date.now()) as any[];
+    const params: any[] = [topic, Date.now()];
 
-    return rows.map(row => ({
-      code: row.code,
-      origin: row.origin,
-      topic: row.topic,
-      info: row.info,
-      offer: row.offer,
-      answer: row.answer || undefined,
-      offerCandidates: JSON.parse(row.offer_candidates),
-      answerCandidates: JSON.parse(row.answer_candidates),
-      createdAt: row.created_at,
-      expiresAt: row.expires_at,
-    }));
-  }
+    if (excludePeerIds && excludePeerIds.length > 0) {
+      const placeholders = excludePeerIds.map(() => '?').join(',');
+      query += ` AND o.peer_id NOT IN (${placeholders})`;
+      params.push(...excludePeerIds);
+    }
 
-  async listTopics(origin: string, page: number, limit: number): Promise<{
-    topics: Array<{ topic: string; count: number }>;
-    pagination: {
-      page: number;
-      limit: number;
-      total: number;
-      hasMore: boolean;
-    };
-  }> {
-    // Ensure limit doesn't exceed 1000
-    const safeLimit = Math.min(Math.max(1, limit), 1000);
-    const safePage = Math.max(1, page);
-    const offset = (safePage - 1) * safeLimit;
-
-    // Get total count of topics
-    const countStmt = this.db.prepare(`
-      SELECT COUNT(DISTINCT topic) as total
-      FROM sessions
-      WHERE origin = ? AND expires_at > ? AND answer IS NULL
-    `);
-    const { total } = countStmt.get(origin, Date.now()) as any;
+    query += ' ORDER BY o.last_seen DESC';
 
-    // Get paginated topics
-    const stmt = this.db.prepare(`
-      SELECT topic, COUNT(*) as count
-      FROM sessions
-      WHERE origin = ? AND expires_at > ? AND answer IS NULL
-      GROUP BY topic
-      ORDER BY topic ASC
-      LIMIT ? OFFSET ?
-    `);
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params) as any[];
 
-    const rows = stmt.all(origin, Date.now(), safeLimit, offset) as any[];
+    return Promise.all(rows.map(row => this.rowToOffer(row)));
+  }
 
-    const topics = rows.map(row => ({
-      topic: row.topic,
-      count: row.count,
-    }));
+  async getOffersByPeerId(peerId: string): Promise<Offer[]> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM offers
+      WHERE peer_id = ? AND expires_at > ?
+      ORDER BY last_seen DESC
+    `);
 
-    return {
-      topics,
-      pagination: {
-        page: safePage,
-        limit: safeLimit,
-        total,
-        hasMore: offset + topics.length < total,
-      },
-    };
+    const rows = stmt.all(peerId, Date.now()) as any[];
+    return Promise.all(rows.map(row => this.rowToOffer(row)));
   }
 
-  async getSession(code: string, origin: string): Promise<Session | null> {
+  async getOfferById(offerId: string): Promise<Offer | null> {
     const stmt = this.db.prepare(`
-      SELECT * FROM sessions WHERE code = ? AND origin = ? AND expires_at > ?
+      SELECT * FROM offers
+      WHERE id = ? AND expires_at > ?
     `);
 
-    const row = stmt.get(code, origin, Date.now()) as any;
+    const row = stmt.get(offerId, Date.now()) as any;
 
     if (!row) {
       return null;
     }
 
-    return {
-      code: row.code,
-      origin: row.origin,
-      topic: row.topic,
-      info: row.info,
-      offer: row.offer,
-      answer: row.answer || undefined,
-      offerCandidates: JSON.parse(row.offer_candidates),
-      answerCandidates: JSON.parse(row.answer_candidates),
-      createdAt: row.created_at,
-      expiresAt: row.expires_at,
-    };
+    return this.rowToOffer(row);
   }
 
-  async updateSession(code: string, origin: string, update: Partial<Session>): Promise<void> {
-    const current = await this.getSession(code, origin);
+  async deleteOffer(offerId: string, ownerPeerId: string): Promise<boolean> {
+    const stmt = this.db.prepare(`
+      DELETE FROM offers
+      WHERE id = ? AND peer_id = ?
+    `);
 
-    if (!current) {
-      throw new Error('Session not found or origin mismatch');
-    }
+    const result = stmt.run(offerId, ownerPeerId);
+    return result.changes > 0;
+  }
 
-    const updates: string[] = [];
-    const values: any[] = [];
+  async deleteExpiredOffers(now: number): Promise<number> {
+    const stmt = this.db.prepare('DELETE FROM offers WHERE expires_at < ?');
+    const result = stmt.run(now);
+    return result.changes;
+  }
 
-    if (update.answer !== undefined) {
-      updates.push('answer = ?');
-      values.push(update.answer);
+  async answerOffer(
+    offerId: string,
+    answererPeerId: string,
+    answerSdp: string,
+    secret?: string
+  ): Promise<{ success: boolean; error?: string }> {
+    // Check if offer exists and is not expired
+    const offer = await this.getOfferById(offerId);
+
+    if (!offer) {
+      return {
+        success: false,
+        error: 'Offer not found or expired'
+      };
     }
 
-    if (update.offerCandidates !== undefined) {
-      updates.push('offer_candidates = ?');
-      values.push(JSON.stringify(update.offerCandidates));
+    // Verify secret if offer is protected
+    if (offer.secret && offer.secret !== secret) {
+      return {
+        success: false,
+        error: 'Invalid or missing secret'
+      };
     }
 
-    if (update.answerCandidates !== undefined) {
-      updates.push('answer_candidates = ?');
-      values.push(JSON.stringify(update.answerCandidates));
+    // Check if offer already has an answerer
+    if (offer.answererPeerId) {
+      return {
+        success: false,
+        error: 'Offer already answered'
+      };
     }
 
-    if (updates.length === 0) {
-      return;
+    // Update offer with answer
+    const stmt = this.db.prepare(`
+      UPDATE offers
+      SET answerer_peer_id = ?, answer_sdp = ?, answered_at = ?
+      WHERE id = ? AND answerer_peer_id IS NULL
+    `);
+
+    const result = stmt.run(answererPeerId, answerSdp, Date.now(), offerId);
+
+    if (result.changes === 0) {
+      return {
+        success: false,
+        error: 'Offer already answered (race condition)'
+      };
     }
 
-    values.push(code);
-    values.push(origin);
+    return { success: true };
+  }
 
+  async getAnsweredOffers(offererPeerId: string): Promise<Offer[]> {
     const stmt = this.db.prepare(`
-      UPDATE sessions SET ${updates.join(', ')} WHERE code = ? AND origin = ?
+      SELECT * FROM offers
+      WHERE peer_id = ? AND answerer_peer_id IS NOT NULL AND expires_at > ?
+      ORDER BY answered_at DESC
     `);
 
-    stmt.run(...values);
+    const rows = stmt.all(offererPeerId, Date.now()) as any[];
+    return Promise.all(rows.map(row => this.rowToOffer(row)));
   }
 
-  async deleteSession(code: string): Promise<void> {
-    const stmt = this.db.prepare('DELETE FROM sessions WHERE code = ?');
-    stmt.run(code);
-  }
+  async addIceCandidates(
+    offerId: string,
+    peerId: string,
+    role: 'offerer' | 'answerer',
+    candidates: any[]
+  ): Promise<number> {
+    const stmt = this.db.prepare(`
+      INSERT INTO ice_candidates (offer_id, peer_id, role, candidate, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
 
-  async cleanup(): Promise<void> {
-    const stmt = this.db.prepare('DELETE FROM sessions WHERE expires_at <= ?');
-    const result = stmt.run(Date.now());
+    const baseTimestamp = Date.now();
+    const transaction = this.db.transaction((candidates: any[]) => {
+      for (let i = 0; i < candidates.length; i++) {
+        stmt.run(
+          offerId,
+          peerId,
+          role,
+          JSON.stringify(candidates[i]), // Store full object as JSON
+          baseTimestamp + i // Ensure unique timestamps to avoid "since" filtering issues
+        );
+      }
+    });
+
+    transaction(candidates);
+    return candidates.length;
+  }
 
-    if (result.changes > 0) {
-      console.log(`Cleaned up ${result.changes} expired session(s)`);
+  async getIceCandidates(
+    offerId: string,
+    targetRole: 'offerer' | 'answerer',
+    since?: number
+  ): Promise<IceCandidate[]> {
+    let query = `
+      SELECT * FROM ice_candidates
+      WHERE offer_id = ? AND role = ?
+    `;
+
+    const params: any[] = [offerId, targetRole];
+
+    if (since !== undefined) {
+      query += ' AND created_at > ?';
+      params.push(since);
     }
+
+    query += ' ORDER BY created_at ASC';
+
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params) as any[];
+
+    return rows.map(row => ({
+      id: row.id,
+      offerId: row.offer_id,
+      peerId: row.peer_id,
+      role: row.role,
+      candidate: JSON.parse(row.candidate), // Parse JSON back to object
+      createdAt: row.created_at,
+    }));
+  }
+
+  async getTopics(limit: number, offset: number, startsWith?: string): Promise<{
+    topics: TopicInfo[];
+    total: number;
+  }> {
+    const now = Date.now();
+
+    // Build WHERE clause for startsWith filter
+    const whereClause = startsWith
+      ? 'o.expires_at > ? AND ot.topic LIKE ?'
+      : 'o.expires_at > ?';
+
+    const startsWithPattern = startsWith ? `${startsWith}%` : null;
+
+    // Get total count of topics with active offers
+    const countQuery = `
+      SELECT COUNT(DISTINCT ot.topic) as count
+      FROM offer_topics ot
+      INNER JOIN offers o ON ot.offer_id = o.id
+      WHERE ${whereClause}
+    `;
+
+    const countStmt = this.db.prepare(countQuery);
+    const countParams = startsWith ? [now, startsWithPattern] : [now];
+    const countRow = countStmt.get(...countParams) as any;
+    const total = countRow.count;
+
+    // Get topics with peer counts (paginated)
+    const topicsQuery = `
+      SELECT
+        ot.topic,
+        COUNT(DISTINCT o.peer_id) as active_peers
+      FROM offer_topics ot
+      INNER JOIN offers o ON ot.offer_id = o.id
+      WHERE ${whereClause}
+      GROUP BY ot.topic
+      ORDER BY active_peers DESC, ot.topic ASC
+      LIMIT ? OFFSET ?
+    `;
+
+    const topicsStmt = this.db.prepare(topicsQuery);
+    const topicsParams = startsWith
+      ? [now, startsWithPattern, limit, offset]
+      : [now, limit, offset];
+    const rows = topicsStmt.all(...topicsParams) as any[];
+
+    const topics = rows.map(row => ({
+      topic: row.topic,
+      activePeers: row.active_peers,
+    }));
+
+    return { topics, total };
   }
 
   async close(): Promise<void> {
     this.db.close();
   }
+
+  /**
+   * Helper method to convert database row to Offer object with topics
+   */
+  private async rowToOffer(row: any): Promise<Offer> {
+    // Get topics for this offer
+    const topicStmt = this.db.prepare(`
+      SELECT topic FROM offer_topics WHERE offer_id = ?
+    `);
+
+    const topicRows = topicStmt.all(row.id) as any[];
+    const topics = topicRows.map(t => t.topic);
+
+    return {
+      id: row.id,
+      peerId: row.peer_id,
+      sdp: row.sdp,
+      topics,
+      createdAt: row.created_at,
+      expiresAt: row.expires_at,
+      lastSeen: row.last_seen,
+      secret: row.secret || undefined,
+      answererPeerId: row.answerer_peer_id || undefined,
+      answerSdp: row.answer_sdp || undefined,
+      answeredAt: row.answered_at || undefined,
+    };
+  }
 }