Authentification & Connexion

Authentification Navigateur

Pour les applications navigateur, utilisez une fonction token provider:

import OptaveJavaScriptSDK from '@optave/client-sdk';

const client = new OptaveJavaScriptSDK({
  websocketUrl: 'wss://ws-{{tenant}}.oco.optave.{{tld}}',
  authTransport: 'subprotocol',
  tokenProvider: async () => {
    // Remplacez '/api/optave-token' par votre véritable endpoint backend
    const response = await fetch('/api/optave-token');
    const { token } = await response.json();
    return token;
  }
});

Note: Ne jamais exposer les secrets client dans le code navigateur. Utilisez un endpoint backend pour récupérer les tokens.

Authentification Serveur

Pour les serveurs Node.js, utilisez la méthode authenticate avec les identifiants client:

import OptaveJavaScriptSDK from '@optave/client-sdk/server';

const client = new OptaveJavaScriptSDK({
  websocketUrl: process.env.OPTAVE_WEBSOCKET_URL,
  authenticationUrl: process.env.OPTAVE_AUTHENTICATION_URL,
  clientId: process.env.OPTAVE_CLIENT_ID,
  clientSecret: process.env.OPTAVE_CLIENT_SECRET
});

async function authenticateAndConnect() {
  try {
    const token = await client.authenticate();
    console.log('Authentification réussie');
    await client.openConnection(token);
    console.log('Connecté');
  } catch (error) {
    console.error('Échec de l\'authentification ou de la connexion:', error);
  }
}

Note: Assurez-vous que authenticationUrl, clientId, et clientSecret sont correctement définis dans la configuration.

Établir une Connexion WebSocket

Après l'authentification (si requise), établissez une connexion WebSocket:

// Avec un token explicite
const token = await client.authenticate();
await client.openConnection(token);

// Ou avec token provider (navigateur)
await client.openConnection();

Important: Utilisation des Tokens JWT

Chaque token JWT ne peut être utilisé qu'une seule fois pour établir une connexion WebSocket. Si vous devez vous reconnecter ou établir une nouvelle connexion, vous devez obtenir un nouveau token en appelant à nouveau authenticate() ou en invoquant votre fonction tokenProvider. Toute tentative de réutilisation du même token entraînera une erreur d'authentification.

Exemple de Reconnexion:

// La reconnexion nécessite un nouveau token
async function reconnect() {
  try {
    // Obtenir un nouveau token
    const newToken = await client.authenticate();
    // Établir une nouvelle connexion avec le nouveau token
    await client.openConnection(newToken);
    console.log('Reconnexion réussie');
  } catch (error) {
    console.error('Échec de la reconnexion:', error);
  }
}

// Gérer la déconnexion
client.on('close', () => {
  console.log('Connexion fermée, reconnexion...');
  reconnect();
});

Options de Configuration

const client = new OptaveJavaScriptSDK({
  websocketUrl: 'wss://ws-{{tenant}}.oco.optave.{{tld}}',
  tokenProvider: async () => { /* ... */ },           // Pour les navigateurs
  authenticationUrl: '...',                           // Pour les serveurs
  clientId: '...',                                    // Pour les serveurs
  clientSecret: '...',                                // Pour les serveurs
  connectionTimeoutMs: 30000,                         // Optionnel (par défaut: 30s)
  requestTimeoutMs: 30000,                            // Optionnel (par défaut: 30s)
  authTransport: 'subprotocol'                        // Optionnel: 'subprotocol' ou 'query'
});