première version avec socketio

2025-09-11 19:55:15 -04:00
parent bc6f95ce1d
commit b260c6ed0b
4 changed files with 325 additions and 54 deletions
--- a/websocket-adapter.js
+++ b/websocket-adapter.js
@@ -0,0 +1,168 @@
+/**
+ * Adaptateur WebSocket pour fallback quand SignalR n'est pas disponible
+ * Émule l'API SignalR avec SocketIO
+ */
+
+const io = require('socket.io-client');
+
+class WebSocketAdapter {
+    constructor(serverUrl, options = {}) {
+        // Nettoyer l'URL et s'assurer qu'elle est valide
+        this.serverUrl = serverUrl;
+        if (this.serverUrl.includes('/signalR')) {
+            this.serverUrl = this.serverUrl.replace('/signalR', '');
+        }
+        // S'assurer qu'on a le protocole
+        if (!this.serverUrl.startsWith('http://') && !this.serverUrl.startsWith('https://')) {
+            this.serverUrl = `http://${this.serverUrl}`;
+        }
+        this.socket = null;
+        this.connected = false;
+        this.handlers = new Map();
+        this.options = options;
+        this.pendingInvocations = new Map();
+        this.invocationId = 0;
+    }
+
+    /**
+     * Émule connection.start() de SignalR
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            console.log(`🔄 Connexion WebSocket à ${this.serverUrl}...`);
+            
+            // Se connecter avec SocketIO
+            this.socket = io(this.serverUrl, {
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionAttempts: 5,
+                reconnectionDelay: 2000,
+                ...this.options
+            });
+
+            this.socket.on('connect', () => {
+                console.log('✅ WebSocket connecté (mode fallback)');
+                this.connected = true;
+                
+                // Émuler l'événement 'connected' de SignalR
+                if (this.handlers.has('connected')) {
+                    this.handlers.get('connected')({ connectionId: this.socket.id });
+                }
+                
+                resolve();
+            });
+
+            this.socket.on('connect_error', (error) => {
+                console.error('❌ Erreur connexion WebSocket:', error.message);
+                reject(error);
+            });
+
+            this.socket.on('disconnect', (reason) => {
+                console.log('🔌 WebSocket déconnecté:', reason);
+                this.connected = false;
+            });
+
+            // Timeout de connexion
+            setTimeout(() => {
+                if (!this.connected) {
+                    reject(new Error('Timeout de connexion WebSocket'));
+                }
+            }, 10000);
+        });
+    }
+
+    /**
+     * Émule connection.stop() de SignalR
+     */
+    async stop() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.connected = false;
+            console.log('🛑 WebSocket fermé');
+        }
+    }
+
+    /**
+     * Émule connection.invoke() de SignalR
+     */
+    async invoke(methodName, ...args) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                reject(new Error('WebSocket non connecté'));
+                return;
+            }
+
+            const invocationId = ++this.invocationId;
+            console.log(`📤 WebSocket invoke: ${methodName}`, args);
+
+            // Stocker la promesse pour la résolution
+            this.pendingInvocations.set(invocationId, { resolve, reject });
+
+            // Émuler le format SignalR mais utiliser l'API SocketIO
+            // SocketIO utilise emit avec un callback pour les réponses
+            this.socket.emit(methodName, ...args, (response) => {
+                console.log(`📥 WebSocket response for ${methodName}:`, response);
+                
+                const pending = this.pendingInvocations.get(invocationId);
+                if (pending) {
+                    pending.resolve(response);
+                    this.pendingInvocations.delete(invocationId);
+                }
+            });
+
+            // Timeout pour éviter les promesses pendantes
+            setTimeout(() => {
+                const pending = this.pendingInvocations.get(invocationId);
+                if (pending) {
+                    pending.reject(new Error(`Timeout invoking ${methodName}`));
+                    this.pendingInvocations.delete(invocationId);
+                }
+            }, 30000);
+        });
+    }
+
+    /**
+     * Émule connection.on() de SignalR
+     */
+    on(eventName, handler) {
+        console.log(`👂 WebSocket listener ajouté: ${eventName}`);
+        this.handlers.set(eventName, handler);
+
+        // Mapper les événements SocketIO vers les handlers
+        if (this.socket) {
+            this.socket.on(eventName, (...args) => {
+                console.log(`📨 WebSocket event reçu: ${eventName}`, args);
+                handler(eventName, args);
+            });
+        }
+    }
+
+    /**
+     * Émule connection.off() de SignalR
+     */
+    off(eventName) {
+        this.handlers.delete(eventName);
+        if (this.socket) {
+            this.socket.off(eventName);
+        }
+    }
+
+    /**
+     * État de la connexion (émule SignalR HubConnectionState)
+     */
+    get state() {
+        if (this.connected) {
+            return 'Connected';
+        }
+        return 'Disconnected';
+    }
+
+    /**
+     * Vérifier si la connexion utilise WebSocket (toujours vrai pour cet adaptateur)
+     */
+    get isWebSocketFallback() {
+        return true;
+    }
+}
+
+module.exports = WebSocketAdapter;