@xtr-dev/rondevu-client 0.3.5 → 0.4.0

package/dist/offers.js

@@ -0,0 +1,214 @@
+import { RondevuAuth } from './auth.js';
+export class RondevuOffers {
+    constructor(baseUrl, credentials, fetchFn) {
+        this.baseUrl = baseUrl;
+        this.credentials = credentials;
+        // Use provided fetch or fall back to global fetch
+        this.fetchFn = fetchFn || ((...args) => {
+            if (typeof globalThis.fetch === 'function') {
+                return globalThis.fetch(...args);
+            }
+            throw new Error('fetch is not available. Please provide a fetch implementation in the constructor options.');
+        });
+    }
+    /**
+     * Create one or more offers
+     */
+    async create(offers) {
+        const response = await this.fetchFn(`${this.baseUrl}/offers`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+            body: JSON.stringify({ offers }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to create offers: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.offers;
+    }
+    /**
+     * Find offers by topic with optional bloom filter
+     */
+    async findByTopic(topic, options) {
+        const params = new URLSearchParams();
+        if (options?.bloomFilter) {
+            // Convert to base64
+            const binaryString = String.fromCharCode(...Array.from(options.bloomFilter));
+            const base64 = typeof btoa !== 'undefined'
+                ? btoa(binaryString)
+                : (typeof Buffer !== 'undefined' ? Buffer.from(options.bloomFilter).toString('base64') : '');
+            params.set('bloom', base64);
+        }
+        if (options?.limit) {
+            params.set('limit', options.limit.toString());
+        }
+        const url = `${this.baseUrl}/offers/by-topic/${encodeURIComponent(topic)}${params.toString() ? '?' + params.toString() : ''}`;
+        const response = await this.fetchFn(url, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to find offers: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.offers;
+    }
+    /**
+     * Get all offers from a specific peer
+     */
+    async getByPeerId(peerId) {
+        const response = await this.fetchFn(`${this.baseUrl}/peers/${encodeURIComponent(peerId)}/offers`, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to get peer offers: ${error.error || response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get topics with active peer counts (paginated)
+     */
+    async getTopics(options) {
+        const params = new URLSearchParams();
+        if (options?.limit) {
+            params.set('limit', options.limit.toString());
+        }
+        if (options?.offset) {
+            params.set('offset', options.offset.toString());
+        }
+        const url = `${this.baseUrl}/topics${params.toString() ? '?' + params.toString() : ''}`;
+        const response = await this.fetchFn(url, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to get topics: ${error.error || response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get own offers
+     */
+    async getMine() {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/mine`, {
+            method: 'GET',
+            headers: {
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to get own offers: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.offers;
+    }
+    /**
+     * Update offer heartbeat
+     */
+    async heartbeat(offerId) {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/heartbeat`, {
+            method: 'PUT',
+            headers: {
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to update heartbeat: ${error.error || response.statusText}`);
+        }
+    }
+    /**
+     * Delete an offer
+     */
+    async delete(offerId) {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}`, {
+            method: 'DELETE',
+            headers: {
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to delete offer: ${error.error || response.statusText}`);
+        }
+    }
+    /**
+     * Answer an offer
+     */
+    async answer(offerId, sdp) {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/answer`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+            body: JSON.stringify({ sdp }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
+        }
+    }
+    /**
+     * Get answers to your offers
+     */
+    async getAnswers() {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/answers`, {
+            method: 'GET',
+            headers: {
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to get answers: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.answers;
+    }
+    /**
+     * Post ICE candidates for an offer
+     */
+    async addIceCandidates(offerId, candidates) {
+        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+            body: JSON.stringify({ candidates }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`);
+        }
+    }
+    /**
+     * Get ICE candidates for an offer
+     */
+    async getIceCandidates(offerId, since) {
+        const params = new URLSearchParams();
+        if (since !== undefined) {
+            params.set('since', since.toString());
+        }
+        const url = `${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates${params.toString() ? '?' + params.toString() : ''}`;
+        const response = await this.fetchFn(url, {
+            method: 'GET',
+            headers: {
+                Authorization: RondevuAuth.createAuthHeader(this.credentials),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return data.candidates;
+    }
+}

package/dist/rondevu.d.ts

@@ -1,60 +1,57 @@
-import { RondevuAPI } from './client.js';
+import { RondevuAuth, Credentials, FetchFunction } from './auth.js';
+import { RondevuOffers } from './offers.js';
 import { RondevuConnection } from './connection.js';
-import { RondevuOptions } from './types.js';
-/**
- * Main Rondevu WebRTC client with automatic connection management
- */
-export declare class Rondevu {
-    readonly peerId: string;
-    readonly api: RondevuAPI;
-    private baseUrl;
-    private fetchImpl?;
-    private rtcConfig?;
-    private pollingInterval;
-    private connectionTimeout;
-    private wrtc?;
-    private RTCPeerConnection;
-    private RTCIceCandidate;
-    /**
-     * Creates a new Rondevu client instance
-     * @param options - Client configuration options
-     */
-    constructor(options?: RondevuOptions);
+export interface RondevuOptions {
     /**
-     * Check server version compatibility
+     * Base URL of the Rondevu server
+     * @default 'https://api.ronde.vu'
      */
-    private checkServerVersion;
+    baseUrl?: string;
     /**
-     * Check if client and server versions are compatible
-     * For now, just check major version compatibility
+     * Existing credentials (peerId + secret) to skip registration
      */
-    private isVersionCompatible;
+    credentials?: Credentials;
     /**
-     * Generate a unique peer ID
+     * Custom fetch implementation for environments without native fetch
+     * (Node.js < 18, some Workers environments, etc.)
+     *
+     * @example Node.js
+     * ```typescript
+     * import fetch from 'node-fetch';
+     * const client = new Rondevu({ fetch });
+     * ```
      */
-    private generatePeerId;
+    fetch?: FetchFunction;
+}
+export declare class Rondevu {
+    readonly auth: RondevuAuth;
+    private _offers?;
+    private credentials?;
+    private baseUrl;
+    private fetchFn?;
+    constructor(options?: RondevuOptions);
     /**
-     * Update the peer ID (useful when user identity changes)
+     * Get offers API (requires authentication)
      */
-    updatePeerId(newPeerId: string): void;
+    get offers(): RondevuOffers;
     /**
-     * Create an offer (offerer role)
-     * @param id - Offer identifier (custom code)
-     * @returns Promise that resolves to RondevuConnection
+     * Register and initialize authenticated client
      */
-    offer(id: string): Promise<RondevuConnection>;
+    register(): Promise<Credentials>;
     /**
-     * Answer an existing offer by ID (answerer role)
-     * @param id - Offer code
-     * @returns Promise that resolves to RondevuConnection
+     * Check if client is authenticated
      */
-    answer(id: string): Promise<RondevuConnection>;
+    isAuthenticated(): boolean;
     /**
-     * Wait for ICE gathering to complete
+     * Get current credentials
      */
-    private waitForIceGathering;
+    getCredentials(): Credentials | undefined;
     /**
-     * Find an offer by code
+     * Create a new WebRTC connection (requires authentication)
+     * This is a high-level helper that creates and manages WebRTC connections
+     *
+     * @param rtcConfig Optional RTCConfiguration for the peer connection
+     * @returns RondevuConnection instance
      */
-    private findOfferById;
+    createConnection(rtcConfig?: RTCConfiguration): RondevuConnection;
 }

package/dist/rondevu.js

@@ -1,199 +1,57 @@
-import { RondevuAPI } from './client.js';
+import { RondevuAuth } from './auth.js';
+import { RondevuOffers } from './offers.js';
 import { RondevuConnection } from './connection.js';
-/**
- * Main Rondevu WebRTC client with automatic connection management
- */
 export class Rondevu {
-    /**
-     * Creates a new Rondevu client instance
-     * @param options - Client configuration options
-     */
     constructor(options = {}) {
         this.baseUrl = options.baseUrl || 'https://api.ronde.vu';
-        this.fetchImpl = options.fetch;
-        this.wrtc = options.wrtc;
-        this.api = new RondevuAPI({
-            baseUrl: this.baseUrl,
-            fetch: options.fetch,
-        });
-        // Auto-generate peer ID if not provided
-        this.peerId = options.peerId || this.generatePeerId();
-        this.rtcConfig = options.rtcConfig;
-        this.pollingInterval = options.pollingInterval || 1000;
-        this.connectionTimeout = options.connectionTimeout || 30000;
-        // Use injected WebRTC polyfill or fall back to global
-        this.RTCPeerConnection = options.wrtc?.RTCPeerConnection || globalThis.RTCPeerConnection;
-        this.RTCIceCandidate = options.wrtc?.RTCIceCandidate || globalThis.RTCIceCandidate;
-        if (!this.RTCPeerConnection) {
-            throw new Error('RTCPeerConnection not available. ' +
-                'In Node.js, provide a WebRTC polyfill via the wrtc option. ' +
-                'Install: npm install @roamhq/wrtc or npm install wrtc');
+        this.fetchFn = options.fetch;
+        this.auth = new RondevuAuth(this.baseUrl, this.fetchFn);
+        if (options.credentials) {
+            this.credentials = options.credentials;
+            this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
         }
-        // Check server version compatibility (async, don't block constructor)
-        this.checkServerVersion().catch(() => {
-            // Silently fail version check - connection will work even if version check fails
-        });
     }
     /**
-     * Check server version compatibility
+     * Get offers API (requires authentication)
      */
-    async checkServerVersion() {
-        try {
-            const { version: serverVersion } = await this.api.health();
-            const clientVersion = '0.3.5'; // Should match package.json
-            if (!this.isVersionCompatible(clientVersion, serverVersion)) {
-                console.warn(`[Rondevu] Version mismatch: client v${clientVersion}, server v${serverVersion}. ` +
-                    'This may cause compatibility issues.');
-            }
+    get offers() {
+        if (!this._offers) {
+            throw new Error('Not authenticated. Call register() first or provide credentials.');
         }
-        catch (error) {
-            // Version check failed - server might not support /health endpoint
-            console.debug('[Rondevu] Could not check server version');
-        }
-    }
-    /**
-     * Check if client and server versions are compatible
-     * For now, just check major version compatibility
-     */
-    isVersionCompatible(clientVersion, serverVersion) {
-        const clientMajor = parseInt(clientVersion.split('.')[0]);
-        const serverMajor = parseInt(serverVersion.split('.')[0]);
-        // Major versions must match
-        return clientMajor === serverMajor;
+        return this._offers;
     }
     /**
-     * Generate a unique peer ID
+     * Register and initialize authenticated client
      */
-    generatePeerId() {
-        return `rdv_${Math.random().toString(36).substring(2, 14)}`;
+    async register() {
+        this.credentials = await this.auth.register();
+        // Create offers API instance
+        this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
+        return this.credentials;
     }
     /**
-     * Update the peer ID (useful when user identity changes)
+     * Check if client is authenticated
      */
-    updatePeerId(newPeerId) {
-        this.peerId = newPeerId;
+    isAuthenticated() {
+        return !!this.credentials;
     }
     /**
-     * Create an offer (offerer role)
-     * @param id - Offer identifier (custom code)
-     * @returns Promise that resolves to RondevuConnection
+     * Get current credentials
      */
-    async offer(id) {
-        // Create peer connection
-        const pc = new this.RTCPeerConnection(this.rtcConfig);
-        // Create initial data channel for negotiation (required for offer creation)
-        pc.createDataChannel('_negotiation');
-        // Generate offer
-        const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
-        // Wait for ICE gathering to complete
-        await this.waitForIceGathering(pc);
-        // Create offer on server with custom code
-        await this.api.createOffer({
-            peerId: this.peerId,
-            offer: pc.localDescription.sdp,
-            code: id,
-        });
-        // Create connection object
-        const connectionParams = {
-            id,
-            role: 'offerer',
-            pc,
-            localPeerId: this.peerId,
-            remotePeerId: '', // Will be populated when answer is received
-            pollingInterval: this.pollingInterval,
-            connectionTimeout: this.connectionTimeout,
-            wrtc: this.wrtc,
-        };
-        const connection = new RondevuConnection(connectionParams, this.api);
-        // Start polling for answer
-        connection.startPolling();
-        return connection;
+    getCredentials() {
+        return this.credentials;
     }
     /**
-     * Answer an existing offer by ID (answerer role)
-     * @param id - Offer code
-     * @returns Promise that resolves to RondevuConnection
+     * Create a new WebRTC connection (requires authentication)
+     * This is a high-level helper that creates and manages WebRTC connections
+     *
+     * @param rtcConfig Optional RTCConfiguration for the peer connection
+     * @returns RondevuConnection instance
      */
-    async answer(id) {
-        // Poll server to get offer by ID
-        const offerData = await this.findOfferById(id);
-        if (!offerData) {
-            throw new Error(`Offer ${id} not found or expired`);
-        }
-        // Create peer connection
-        const pc = new this.RTCPeerConnection(this.rtcConfig);
-        // Set remote offer
-        await pc.setRemoteDescription({
-            type: 'offer',
-            sdp: offerData.offer,
-        });
-        // Generate answer
-        const answer = await pc.createAnswer();
-        await pc.setLocalDescription(answer);
-        // Wait for ICE gathering
-        await this.waitForIceGathering(pc);
-        // Send answer to server
-        await this.api.sendAnswer({
-            code: id,
-            answer: pc.localDescription.sdp,
-            side: 'answerer',
-        });
-        // Create connection object
-        const connectionParams = {
-            id,
-            role: 'answerer',
-            pc,
-            localPeerId: this.peerId,
-            remotePeerId: '', // Will be determined from peerId in offer
-            pollingInterval: this.pollingInterval,
-            connectionTimeout: this.connectionTimeout,
-            wrtc: this.wrtc,
-        };
-        const connection = new RondevuConnection(connectionParams, this.api);
-        // Start polling for ICE candidates
-        connection.startPolling();
-        return connection;
-    }
-    /**
-     * Wait for ICE gathering to complete
-     */
-    async waitForIceGathering(pc) {
-        if (pc.iceGatheringState === 'complete') {
-            return;
-        }
-        return new Promise((resolve) => {
-            const checkState = () => {
-                if (pc.iceGatheringState === 'complete') {
-                    pc.removeEventListener('icegatheringstatechange', checkState);
-                    resolve();
-                }
-            };
-            pc.addEventListener('icegatheringstatechange', checkState);
-            // Also set a timeout in case gathering takes too long
-            setTimeout(() => {
-                pc.removeEventListener('icegatheringstatechange', checkState);
-                resolve();
-            }, 5000);
-        });
-    }
-    /**
-     * Find an offer by code
-     */
-    async findOfferById(id) {
-        try {
-            // Poll for the offer directly
-            const response = await this.api.poll(id, 'answerer');
-            const answererResponse = response;
-            if (answererResponse.offer) {
-                return {
-                    offer: answererResponse.offer,
-                };
-            }
-            return null;
-        }
-        catch (err) {
-            throw new Error(`Failed to find offer ${id}: ${err.message}`);
+    createConnection(rtcConfig) {
+        if (!this._offers) {
+            throw new Error('Not authenticated. Call register() first or provide credentials.');
         }
+        return new RondevuConnection(this._offers, rtcConfig);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.3.5",
-  "description": "TypeScript client for Rondevu peer signaling and discovery server",
+  "version": "0.4.0",
+  "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",