@xtr-dev/rondevu-server 0.0.1 → 0.1.1

package/src/storage/d1.ts

@@ -0,0 +1,394 @@
+import { Storage, Offer, IceCandidate, CreateOfferRequest, TopicInfo } from './types.ts';
+import { generateOfferHash } from './hash-id.ts';
+
+/**
+ * D1 storage adapter for topic-based offer management using Cloudflare D1
+ * NOTE: This implementation is a placeholder and needs to be fully tested
+ */
+export class D1Storage implements Storage {
+  private db: D1Database;
+
+  /**
+   * Creates a new D1 storage instance
+   * @param db D1Database instance from Cloudflare Workers environment
+   */
+  constructor(db: D1Database) {
+    this.db = db;
+  }
+
+  /**
+   * Initializes database schema with new topic-based structure
+   * This should be run once during setup, not on every request
+   */
+  async initializeDatabase(): Promise<void> {
+    await this.db.exec(`
+      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,
+        last_seen INTEGER NOT NULL,
+        secret TEXT,
+        answerer_peer_id TEXT,
+        answer_sdp TEXT,
+        answered_at INTEGER
+      );
+
+      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);
+
+      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
+      );
+
+      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);
+
+      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
+      );
+
+      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);
+    `);
+  }
+
+  async createOffers(offers: CreateOfferRequest[]): Promise<Offer[]> {
+    const created: Offer[] = [];
+
+    // D1 doesn't support true transactions yet, so we do this sequentially
+    for (const offer of offers) {
+      const id = offer.id || await generateOfferHash(offer.sdp, offer.topics);
+      const now = Date.now();
+
+      // Insert offer
+      await this.db.prepare(`
+        INSERT INTO offers (id, peer_id, sdp, created_at, expires_at, last_seen, secret)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).bind(id, offer.peerId, offer.sdp, now, offer.expiresAt, now, offer.secret || null).run();
+
+      // Insert topics
+      for (const topic of offer.topics) {
+        await this.db.prepare(`
+          INSERT INTO offer_topics (offer_id, topic)
+          VALUES (?, ?)
+        `).bind(id, topic).run();
+      }
+
+      created.push({
+        id,
+        peerId: offer.peerId,
+        sdp: offer.sdp,
+        topics: offer.topics,
+        createdAt: now,
+        expiresAt: offer.expiresAt,
+        lastSeen: now,
+        secret: offer.secret,
+      });
+    }
+
+    return created;
+  }
+
+  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 params: any[] = [topic, Date.now()];
+
+    if (excludePeerIds && excludePeerIds.length > 0) {
+      const placeholders = excludePeerIds.map(() => '?').join(',');
+      query += ` AND o.peer_id NOT IN (${placeholders})`;
+      params.push(...excludePeerIds);
+    }
+
+    query += ' ORDER BY o.last_seen DESC';
+
+    const result = await this.db.prepare(query).bind(...params).all();
+
+    if (!result.results) {
+      return [];
+    }
+
+    return Promise.all(result.results.map(row => this.rowToOffer(row as any)));
+  }
+
+  async getOffersByPeerId(peerId: string): Promise<Offer[]> {
+    const result = await this.db.prepare(`
+      SELECT * FROM offers
+      WHERE peer_id = ? AND expires_at > ?
+      ORDER BY last_seen DESC
+    `).bind(peerId, Date.now()).all();
+
+    if (!result.results) {
+      return [];
+    }
+
+    return Promise.all(result.results.map(row => this.rowToOffer(row as any)));
+  }
+
+  async getOfferById(offerId: string): Promise<Offer | null> {
+    const result = await this.db.prepare(`
+      SELECT * FROM offers
+      WHERE id = ? AND expires_at > ?
+    `).bind(offerId, Date.now()).first();
+
+    if (!result) {
+      return null;
+    }
+
+    return this.rowToOffer(result as any);
+  }
+
+  async deleteOffer(offerId: string, ownerPeerId: string): Promise<boolean> {
+    const result = await this.db.prepare(`
+      DELETE FROM offers
+      WHERE id = ? AND peer_id = ?
+    `).bind(offerId, ownerPeerId).run();
+
+    return (result.meta.changes || 0) > 0;
+  }
+
+  async deleteExpiredOffers(now: number): Promise<number> {
+    const result = await this.db.prepare(`
+      DELETE FROM offers WHERE expires_at < ?
+    `).bind(now).run();
+
+    return result.meta.changes || 0;
+  }
+
+  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'
+      };
+    }
+
+    // Verify secret if offer is protected
+    if (offer.secret && offer.secret !== secret) {
+      return {
+        success: false,
+        error: 'Invalid or missing secret'
+      };
+    }
+
+    // Check if offer already has an answerer
+    if (offer.answererPeerId) {
+      return {
+        success: false,
+        error: 'Offer already answered'
+      };
+    }
+
+    // Update offer with answer
+    const result = await this.db.prepare(`
+      UPDATE offers
+      SET answerer_peer_id = ?, answer_sdp = ?, answered_at = ?
+      WHERE id = ? AND answerer_peer_id IS NULL
+    `).bind(answererPeerId, answerSdp, Date.now(), offerId).run();
+
+    if ((result.meta.changes || 0) === 0) {
+      return {
+        success: false,
+        error: 'Offer already answered (race condition)'
+      };
+    }
+
+    return { success: true };
+  }
+
+  async getAnsweredOffers(offererPeerId: string): Promise<Offer[]> {
+    const result = await this.db.prepare(`
+      SELECT * FROM offers
+      WHERE peer_id = ? AND answerer_peer_id IS NOT NULL AND expires_at > ?
+      ORDER BY answered_at DESC
+    `).bind(offererPeerId, Date.now()).all();
+
+    if (!result.results) {
+      return [];
+    }
+
+    return Promise.all(result.results.map(row => this.rowToOffer(row as any)));
+  }
+
+  async addIceCandidates(
+    offerId: string,
+    peerId: string,
+    role: 'offerer' | 'answerer',
+    candidates: any[]
+  ): Promise<number> {
+    console.log(`[D1] addIceCandidates: offerId=${offerId}, peerId=${peerId}, role=${role}, count=${candidates.length}`);
+
+    // Give each candidate a unique timestamp to avoid "since" filtering issues
+    // D1 doesn't have transactions, so insert one by one
+    for (let i = 0; i < candidates.length; i++) {
+      const timestamp = Date.now() + i; // Ensure unique timestamps
+      await this.db.prepare(`
+        INSERT INTO ice_candidates (offer_id, peer_id, role, candidate, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).bind(
+        offerId,
+        peerId,
+        role,
+        JSON.stringify(candidates[i]), // Store full object as JSON
+        timestamp
+      ).run();
+    }
+
+    return candidates.length;
+  }
+
+  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';
+
+    console.log(`[D1] getIceCandidates query: offerId=${offerId}, targetRole=${targetRole}, since=${since}`);
+    const result = await this.db.prepare(query).bind(...params).all();
+    console.log(`[D1] getIceCandidates result: ${result.results?.length || 0} rows`);
+
+    if (!result.results) {
+      return [];
+    }
+
+    const candidates = result.results.map((row: any) => ({
+      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,
+    }));
+
+    if (candidates.length > 0) {
+      console.log(`[D1] First candidate createdAt: ${candidates[0].createdAt}, since: ${since}`);
+    }
+
+    return candidates;
+  }
+
+  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 countResult = startsWith
+      ? await countStmt.bind(now, startsWithPattern).first()
+      : await countStmt.bind(now).first();
+
+    const total = (countResult as any)?.count || 0;
+
+    // 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 topicsResult = startsWith
+      ? await topicsStmt.bind(now, startsWithPattern, limit, offset).all()
+      : await topicsStmt.bind(now, limit, offset).all();
+
+    const topics = (topicsResult.results || []).map((row: any) => ({
+      topic: row.topic,
+      activePeers: row.active_peers,
+    }));
+
+    return { topics, total };
+  }
+
+  async close(): Promise<void> {
+    // D1 doesn't require explicit connection closing
+    // Connections are managed by the Cloudflare Workers runtime
+  }
+
+  /**
+   * Helper method to convert database row to Offer object with topics
+   */
+  private async rowToOffer(row: any): Promise<Offer> {
+    // Get topics for this offer
+    const topicResult = await this.db.prepare(`
+      SELECT topic FROM offer_topics WHERE offer_id = ?
+    `).bind(row.id).all();
+
+    const topics = topicResult.results?.map((t: any) => 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,
+    };
+  }
+}

package/src/storage/hash-id.ts

@@ -0,0 +1,37 @@
+/**
+ * Generates a content-based offer ID using SHA-256 hash
+ * Creates deterministic IDs based on offer content (sdp, topics)
+ * PeerID is not included as it's inferred from authentication
+ * Uses Web Crypto API for compatibility with both Node.js and Cloudflare Workers
+ *
+ * @param sdp - The WebRTC SDP offer
+ * @param topics - Array of topic strings
+ * @returns SHA-256 hash of the sanitized offer content
+ */
+export async function generateOfferHash(
+  sdp: string,
+  topics: string[]
+): Promise<string> {
+  // Sanitize and normalize the offer content
+  // Only include core offer content (not peerId - that's inferred from auth)
+  const sanitizedOffer = {
+    sdp,
+    topics: [...topics].sort(), // Sort topics for consistency
+  };
+
+  // Create non-prettified JSON string
+  const jsonString = JSON.stringify(sanitizedOffer);
+
+  // Convert string to Uint8Array for hashing
+  const encoder = new TextEncoder();
+  const data = encoder.encode(jsonString);
+
+  // Generate SHA-256 hash
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+
+  // Convert hash to hex string
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+  return hashHex;
+}