@xtr-dev/rondevu-server 0.5.20 → 0.5.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-server",
-  "version": "0.5.20",
+  "version": "0.5.25",
   "description": "DNS-like WebRTC signaling server with credential-based authentication and service discovery",
   "main": "dist/index.js",
   "scripts": {

package/src/config.ts

@@ -95,7 +95,7 @@ export const CONFIG_DEFAULTS = {
   offerDefaultTtl: 60000,
   offerMaxTtl: 86400000,
   offerMinTtl: 60000,
-  answeredOfferTtl: 30000, // 30 seconds TTL after offer is answered
+  answeredOfferTtl: 60000, // 60 seconds TTL after offer is answered
   cleanupInterval: 60000,
   maxOffersPerRequest: 100,
   maxBatchSize: 100,

package/src/rpc.ts

@@ -128,6 +128,11 @@ export interface DiscoverParams {
   offset?: number;
 }
 
+export interface CountOffersByTagsParams {
+  tags: string[];
+  unique?: boolean;
+}
+
 export interface PublishOfferParams {
   tags: string[];
   offers: Array<{ sdp: string }>;
@@ -300,6 +305,28 @@ const handlers: Record<string, RpcHandler> = {
     };
   },
 
+  /**
+   * Count available offers by tags
+   */
+  async countOffersByTags(params: CountOffersByTagsParams, publicKey, timestamp, signature, storage, config, request: RpcRequest) {
+    const { tags, unique } = params;
+
+    const tagsValidation = validateTags(tags);
+    if (!tagsValidation.valid) {
+      throw new RpcError(ErrorCodes.INVALID_TAG, tagsValidation.error || 'Invalid tags');
+    }
+
+    const counts = await storage.countOffersByTags(tags, unique === true);
+
+    // Convert Map to object for JSON serialization
+    const result: Record<string, number> = {};
+    for (const [tag, count] of counts) {
+      result[tag] = count;
+    }
+
+    return { counts: result };
+  },
+
   /**
    * Publish offers with tags
    */
@@ -456,6 +483,7 @@ const handlers: Record<string, RpcHandler> = {
 
     // Reduce TTL after answer for faster cleanup (answered offers no longer appear in discovery)
     const newExpiresAt = Date.now() + config.answeredOfferTtl;
+
     await storage.answerOffer(offerId, publicKey, sdp, matchedTags, newExpiresAt);
 
     return { success: true, offerId };
@@ -510,6 +538,7 @@ const handlers: Record<string, RpcHandler> = {
     const sinceTimestamp = since !== undefined ? since : 0;
 
     const answeredOffers = await storage.getAnsweredOffers(publicKey);
+
     const filteredAnswers = answeredOffers.filter(
       (offer) => offer.answeredAt && offer.answeredAt > sinceTimestamp
     );
@@ -669,7 +698,7 @@ const handlers: Record<string, RpcHandler> = {
 };
 
 // Methods that don't require authentication
-const UNAUTHENTICATED_METHODS = new Set(['discover']);
+const UNAUTHENTICATED_METHODS = new Set(['discover', 'countOffersByTags']);
 
 /**
  * Handle RPC batch request with header-based authentication

package/src/storage/d1.ts

@@ -378,48 +378,54 @@ export class D1Storage implements Storage {
       throw new Error('Too many offer IDs (max 1000)');
     }
 
-    const placeholders = offerIds.map(() => '?').join(',');
-
-    let query = `
-      SELECT ic.*, o.public_key as offer_public_key
-      FROM ice_candidates ic
-      INNER JOIN offers o ON o.id = ic.offer_id
-      WHERE ic.offer_id IN (${placeholders})
-      AND (
-        (o.public_key = ? AND ic.role = 'answerer')
-        OR (o.answerer_public_key = ? AND ic.role = 'offerer')
-      )
-    `;
-
-    const params: any[] = [...offerIds, publicKey, publicKey];
-
-    if (since !== undefined) {
-      query += ' AND ic.created_at > ?';
-      params.push(since);
-    }
-
-    query += ' ORDER BY ic.created_at ASC';
-
-    const queryResult = await this.db.prepare(query).bind(...params).all();
-
-    if (!queryResult.results) {
-      return result;
-    }
+    // D1 has a limit of ~100 bind parameters per query, so batch queries
+    // Each query uses: offerIds.length + 2 (publicKey twice) + 1 (optional since) params
+    // Use batches of 90 offer IDs to stay safely under the limit
+    const BATCH_SIZE = 90;
+
+    for (let i = 0; i < offerIds.length; i += BATCH_SIZE) {
+      const batchOfferIds = offerIds.slice(i, i + BATCH_SIZE);
+      const placeholders = batchOfferIds.map(() => '?').join(',');
+
+      let query = `
+        SELECT ic.*, o.public_key as offer_public_key
+        FROM ice_candidates ic
+        INNER JOIN offers o ON o.id = ic.offer_id
+        WHERE ic.offer_id IN (${placeholders})
+        AND (
+          (o.public_key = ? AND ic.role = 'answerer')
+          OR (o.answerer_public_key = ? AND ic.role = 'offerer')
+        )
+      `;
+
+      const params: any[] = [...batchOfferIds, publicKey, publicKey];
+
+      if (since !== undefined) {
+        query += ' AND ic.created_at > ?';
+        params.push(since);
+      }
 
-    for (const row of queryResult.results as any[]) {
-      const candidate: IceCandidate = {
-        id: row.id,
-        offerId: row.offer_id,
-        publicKey: row.public_key,
-        role: row.role,
-        candidate: JSON.parse(row.candidate),
-        createdAt: row.created_at,
-      };
-
-      if (!result.has(row.offer_id)) {
-        result.set(row.offer_id, []);
+      query += ' ORDER BY ic.created_at ASC';
+
+      const queryResult = await this.db.prepare(query).bind(...params).all();
+
+      if (queryResult.results) {
+        for (const row of queryResult.results as any[]) {
+          const candidate: IceCandidate = {
+            id: row.id,
+            offerId: row.offer_id,
+            publicKey: row.public_key,
+            role: row.role,
+            candidate: JSON.parse(row.candidate),
+            createdAt: row.created_at,
+          };
+
+          if (!result.has(row.offer_id)) {
+            result.set(row.offer_id, []);
+          }
+          result.get(row.offer_id)!.push(candidate);
+        }
       }
-      result.get(row.offer_id)!.push(candidate);
     }
 
     return result;
@@ -508,6 +514,29 @@ export class D1Storage implements Storage {
     return result?.count ?? 0;
   }
 
+  async countOffersByTags(tags: string[], unique = false): Promise<Map<string, number>> {
+    const result = new Map<string, number>();
+    if (tags.length === 0) return result;
+
+    const now = Date.now();
+
+    // Query each tag individually using json_each
+    for (const tag of tags) {
+      const countColumn = unique ? 'COUNT(DISTINCT o.public_key)' : 'COUNT(DISTINCT o.id)';
+      const queryResult = await this.db.prepare(`
+        SELECT ${countColumn} as count
+        FROM offers o, json_each(o.tags) as t
+        WHERE t.value = ?
+          AND o.expires_at > ?
+          AND o.answerer_public_key IS NULL
+      `).bind(tag, now).first() as { count: number } | null;
+
+      result.set(tag, queryResult?.count ?? 0);
+    }
+
+    return result;
+  }
+
   // ===== Helper Methods =====
 
   private rowToOffer(row: any): Offer {

package/src/storage/memory.ts

@@ -445,6 +445,45 @@ export class MemoryStorage implements Storage {
     return candidates ? candidates.length : 0;
   }
 
+  async countOffersByTags(tags: string[], unique = false): Promise<Map<string, number>> {
+    const result = new Map<string, number>();
+    if (tags.length === 0) return result;
+
+    const now = Date.now();
+
+    for (const tag of tags) {
+      const offerIds = this.offersByTag.get(tag);
+      if (!offerIds) {
+        result.set(tag, 0);
+        continue;
+      }
+
+      if (unique) {
+        // Count unique public keys
+        const uniquePublicKeys = new Set<string>();
+        for (const offerId of offerIds) {
+          const offer = this.offers.get(offerId);
+          if (offer && offer.expiresAt > now && !offer.answererPublicKey) {
+            uniquePublicKeys.add(offer.publicKey);
+          }
+        }
+        result.set(tag, uniquePublicKeys.size);
+      } else {
+        // Count total offers
+        let count = 0;
+        for (const offerId of offerIds) {
+          const offer = this.offers.get(offerId);
+          if (offer && offer.expiresAt > now && !offer.answererPublicKey) {
+            count++;
+          }
+        }
+        result.set(tag, count);
+      }
+    }
+
+    return result;
+  }
+
   // ===== Helper Methods =====
 
   private removeOfferFromIndexes(offer: Offer): void {

package/src/storage/mysql.ts

@@ -476,6 +476,29 @@ export class MySQLStorage implements Storage {
     return Number(rows[0].count);
   }
 
+  async countOffersByTags(tags: string[], unique = false): Promise<Map<string, number>> {
+    const result = new Map<string, number>();
+    if (tags.length === 0) return result;
+
+    const now = Date.now();
+
+    // Query each tag individually using JSON_CONTAINS
+    for (const tag of tags) {
+      const countColumn = unique ? 'COUNT(DISTINCT public_key)' : 'COUNT(DISTINCT id)';
+      const [rows] = await this.pool.query<RowDataPacket[]>(
+        `SELECT ${countColumn} as count
+         FROM offers
+         WHERE JSON_CONTAINS(tags, ?)
+           AND expires_at > ?
+           AND answerer_public_key IS NULL`,
+        [JSON.stringify(tag), now]
+      );
+      result.set(tag, Number(rows[0].count));
+    }
+
+    return result;
+  }
+
   // ===== Helper Methods =====
 
   private rowToOffer(row: RowDataPacket): Offer {

package/src/storage/postgres.ts

@@ -484,6 +484,29 @@ export class PostgreSQLStorage implements Storage {
     return Number(result.rows[0].count);
   }
 
+  async countOffersByTags(tags: string[], unique = false): Promise<Map<string, number>> {
+    const result = new Map<string, number>();
+    if (tags.length === 0) return result;
+
+    const now = Date.now();
+
+    // Query each tag individually using JSONB containment
+    for (const tag of tags) {
+      const countColumn = unique ? 'COUNT(DISTINCT public_key)' : 'COUNT(DISTINCT id)';
+      const queryResult = await this.pool.query(
+        `SELECT ${countColumn} as count
+         FROM offers
+         WHERE tags ? $1
+           AND expires_at > $2
+           AND answerer_public_key IS NULL`,
+        [tag, now]
+      );
+      result.set(tag, Number(queryResult.rows[0].count));
+    }
+
+    return result;
+  }
+
   // ===== Helper Methods =====
 
   private rowToOffer(row: any): Offer {

package/src/storage/sqlite.ts

@@ -543,6 +543,31 @@ export class SQLiteStorage implements Storage {
     return result.count;
   }
 
+  async countOffersByTags(tags: string[], unique = false): Promise<Map<string, number>> {
+    const result = new Map<string, number>();
+    if (tags.length === 0) return result;
+
+    const now = Date.now();
+
+    // Query counts for each tag individually for accuracy
+    // (an offer with multiple matching tags should only count once per tag)
+    const countColumn = unique ? 'COUNT(DISTINCT o.public_key)' : 'COUNT(DISTINCT o.id)';
+    const stmt = this.db.prepare(`
+      SELECT ${countColumn} as count
+      FROM offers o, json_each(o.tags) as t
+      WHERE t.value = ?
+        AND o.expires_at > ?
+        AND o.answerer_public_key IS NULL
+    `);
+
+    for (const tag of tags) {
+      const row = stmt.get(tag, now) as { count: number };
+      result.set(tag, row.count);
+    }
+
+    return result;
+  }
+
   // ===== Helper Methods =====
 
   /**

package/src/storage/types.ts

@@ -255,4 +255,12 @@ export interface Storage {
    * @returns ICE candidate count for offer
    */
   getIceCandidateCount(offerId: string): Promise<number>;
+
+  /**
+   * Counts available (unanswered, non-expired) offers for each of the given tags
+   * @param tags Array of tags to count offers for
+   * @param unique If true, count unique public keys instead of total offers
+   * @returns Map of tag to count
+   */
+  countOffersByTags(tags: string[], unique?: boolean): Promise<Map<string, number>>;
 }