gameglue 1.2.4 → 2.0.0

package/src/auth.spec.js

@@ -43,9 +43,9 @@ describe('GameGlueAuth', () => {
     console.log = originalConsoleLog;
     console.error = originalConsoleError;
     jest.useRealTimers();
-    // Clear storage by setting to undefined (mimics clearing)
-    storage.set('gg-auth-token', undefined);
-    storage.set('gg-refresh-token', undefined);
+    // Clear storage
+    storage.remove('gg-auth-token');
+    storage.remove('gg-refresh-token');
   });
 
   describe('constructor', () => {
@@ -96,59 +96,73 @@ describe('GameGlueAuth', () => {
     });
   });
 
-  describe('setAccessToken / getAccessToken', () => {
+  describe('_setAccessToken / getAccessToken', () => {
     it('should store and retrieve access token', () => {
-      auth.setAccessToken(validAccessToken);
+      auth._setAccessToken(validAccessToken);
       const retrieved = auth.getAccessToken();
 
       expect(retrieved).toBe(validAccessToken);
     });
 
     it('should set up token refresh timeout when setting token', () => {
-      auth.setAccessToken(validAccessToken);
+      auth._setAccessToken(validAccessToken);
 
       // Check that a timeout was scheduled
       expect(jest.getTimerCount()).toBeGreaterThan(0);
     });
 
     it('should not set timeout for null token', () => {
-      auth.setAccessToken(null);
+      auth._setAccessToken(null);
 
       expect(jest.getTimerCount()).toBe(0);
     });
   });
 
-  describe('setRefreshToken / getRefreshToken', () => {
+  describe('_setRefreshToken / _getRefreshToken', () => {
     it('should store and retrieve refresh token', () => {
-      auth.setRefreshToken(validRefreshToken);
-      const retrieved = auth.getRefreshToken();
+      auth._setRefreshToken(validRefreshToken);
+      const retrieved = auth._getRefreshToken();
 
       expect(retrieved).toBe(validRefreshToken);
     });
   });
 
-  describe('getUserId', () => {
+  describe('getUser', () => {
     it('should extract user ID from JWT', () => {
-      auth.setAccessToken(validAccessToken);
+      auth._setAccessToken(validAccessToken);
 
-      const userId = auth.getUserId();
+      const userId = auth.getUser();
 
       expect(userId).toBe('user-123');
     });
+
+    it('should throw error when not authenticated', () => {
+      expect(() => auth.getUser()).toThrow('Not authenticated');
+    });
   });
 
-  describe('isTokenExpired', () => {
-    it('should return false for valid token', () => {
-      const result = auth.isTokenExpired(validAccessToken);
+  describe('_hasValidTokens', () => {
+    it('should return false when no token exists', () => {
+      const result = auth._hasValidTokens();
 
       expect(result).toBe(false);
     });
 
-    it('should return true for expired token', () => {
-      const result = auth.isTokenExpired(expiredAccessToken);
+    it('should return true for valid non-expired token', () => {
+      auth._setAccessToken(validAccessToken);
+
+      const result = auth._hasValidTokens();
 
       expect(result).toBe(true);
     });
+
+    it('should return false for expired token', () => {
+      auth._setAccessToken(expiredAccessToken);
+
+      const result = auth._hasValidTokens();
+
+      expect(result).toBe(false);
+    });
   });
 
   describe('isAuthenticated', () => {
@@ -159,51 +173,96 @@ describe('GameGlueAuth', () => {
     });
 
     it('should return true for valid non-expired token', async () => {
-      auth.setAccessToken(validAccessToken);
+      auth._setAccessToken(validAccessToken);
 
       const result = await auth.isAuthenticated();
 
       expect(result).toBe(true);
     });
 
-    it('should attempt refresh for expired token', async () => {
-      auth.setAccessToken(expiredAccessToken);
-      auth.setRefreshToken(validRefreshToken);
-
-      // Mock successful refresh
-      global.fetch.mockResolvedValueOnce({
-        status: 200,
-        json: () =>
-          Promise.resolve({
-            access_token: validAccessToken,
-            refresh_token: validRefreshToken
-          })
-      });
+    it('should return false for expired token', async () => {
+      auth._setAccessToken(expiredAccessToken);
 
       const result = await auth.isAuthenticated();
 
-      expect(global.fetch).toHaveBeenCalled();
+      expect(result).toBe(false);
     });
 
-    it('should return false when refresh fails and token is still expired', async () => {
-      auth.setAccessToken(expiredAccessToken);
-      auth.setRefreshToken(validRefreshToken);
+    it('should process callback params if present in URL', async () => {
+      window.location.hash = '#state=abc123&code=xyz789';
 
-      // Mock failed refresh
-      global.fetch.mockResolvedValueOnce({
-        status: 401,
-        json: () => Promise.resolve({ error: 'invalid_grant' })
-      });
+      const { OidcClient } = require('oidc-client-ts');
+      OidcClient.mockImplementation(() => ({
+        createSigninRequest: jest.fn(),
+        processSigninResponse: jest.fn().mockResolvedValue({
+          access_token: validAccessToken,
+          refresh_token: validRefreshToken
+        })
+      }));
 
-      const result = await auth.isAuthenticated();
+      const authNew = new GameGlueAuth(mockConfig);
+      const result = await authNew.isAuthenticated();
 
-      expect(result).toBe(false);
+      expect(result).toBe(true);
+      // URL should be cleared
+      expect(window.history.replaceState).toHaveBeenCalled();
     });
   });
 
-  describe('attemptRefresh', () => {
+  describe('login', () => {
+    it('should call createSigninRequest', async () => {
+      const createSigninRequest = jest.fn().mockResolvedValue({ url: 'https://auth.example.com/login' });
+      const { OidcClient } = require('oidc-client-ts');
+      OidcClient.mockImplementation(() => ({
+        createSigninRequest,
+        processSigninResponse: jest.fn()
+      }));
+
+      const authNew = new GameGlueAuth(mockConfig);
+      authNew.login();
+
+      // Wait for promise to resolve
+      await Promise.resolve();
+
+      expect(createSigninRequest).toHaveBeenCalledWith({ state: { bar: 15 } });
+    });
+  });
+
+  describe('logout', () => {
+    it('should clear tokens from storage', () => {
+      auth._setAccessToken(validAccessToken);
+      auth._setRefreshToken(validRefreshToken);
+
+      auth.logout({ redirect: false });
+
+      // After remove, storage.get returns undefined in Node environment (in-memory map)
+      expect(auth.getAccessToken()).toBeUndefined();
+      expect(auth._getRefreshToken()).toBeUndefined();
+    });
+
+    it('should not clear tokens when redirect: false not passed', () => {
+      // We can't easily test the redirect behavior in jsdom, but we can verify
+      // the method accepts options and clears tokens regardless
+      auth._setAccessToken(validAccessToken);
+      auth._setRefreshToken(validRefreshToken);
+
+      // logout() clears tokens first, then redirects
+      auth.logout({ redirect: false });
+
+      expect(auth.getAccessToken()).toBeUndefined();
+    });
+
+    it('should accept options object', () => {
+      auth._setAccessToken(validAccessToken);
+
+      // Should not throw when called with different options
+      expect(() => auth.logout({ redirect: false })).not.toThrow();
+    });
+  });
+
+  describe('_attemptRefresh', () => {
     it('should call token endpoint with correct parameters', async () => {
-      auth.setRefreshToken(validRefreshToken);
+      auth._setRefreshToken(validRefreshToken);
 
       global.fetch.mockResolvedValueOnce({
         status: 200,
@@ -214,7 +273,7 @@ describe('GameGlueAuth', () => {
           })
       });
 
-      await auth.attemptRefresh();
+      await auth._attemptRefresh();
 
       expect(global.fetch).toHaveBeenCalledWith(
         'https://auth.gameglue.gg/realms/GameGlue/protocol/openid-connect/token',
@@ -228,7 +287,7 @@ describe('GameGlueAuth', () => {
     });
 
     it('should update tokens on successful refresh', async () => {
-      auth.setRefreshToken(validRefreshToken);
+      auth._setRefreshToken(validRefreshToken);
 
       const newAccessToken = createMockJwt({ sub: 'user-456' }, 3600);
       const newRefreshToken = createMockJwt({ sub: 'user-456', type: 'refresh' }, 86400);
@@ -242,16 +301,16 @@ describe('GameGlueAuth', () => {
           })
       });
 
-      await auth.attemptRefresh();
+      await auth._attemptRefresh();
 
       expect(auth.getAccessToken()).toBe(newAccessToken);
-      expect(auth.getRefreshToken()).toBe(newRefreshToken);
+      expect(auth._getRefreshToken()).toBe(newRefreshToken);
     });
 
-    it('should call refresh callback on successful refresh', async () => {
+    it('should call refresh callback with access token on successful refresh', async () => {
       const callback = jest.fn();
       auth.onTokenRefreshed(callback);
-      auth.setRefreshToken(validRefreshToken);
+      auth._setRefreshToken(validRefreshToken);
 
       const responseData = {
         access_token: validAccessToken,
@@ -263,21 +322,21 @@ describe('GameGlueAuth', () => {
         json: () => Promise.resolve(responseData)
       });
 
-      await auth.attemptRefresh();
+      await auth._attemptRefresh();
 
-      expect(callback).toHaveBeenCalledWith(responseData);
+      expect(callback).toHaveBeenCalledWith(validAccessToken);
     });
 
     it('should handle network errors gracefully', async () => {
-      auth.setRefreshToken(validRefreshToken);
+      auth._setRefreshToken(validRefreshToken);
       global.fetch.mockRejectedValueOnce(new Error('Network error'));
 
       // Should not throw
-      await expect(auth.attemptRefresh()).resolves.toBeUndefined();
+      await expect(auth._attemptRefresh()).resolves.toBeUndefined();
     });
 
     it('should not update tokens on non-200 response', async () => {
-      auth.setRefreshToken(validRefreshToken);
+      auth._setRefreshToken(validRefreshToken);
       const originalAccessToken = auth.getAccessToken();
 
       global.fetch.mockResolvedValueOnce({
@@ -285,9 +344,9 @@ describe('GameGlueAuth', () => {
         json: () => Promise.resolve({ error: 'invalid_grant' })
       });
 
-      await auth.attemptRefresh();
+      await auth._attemptRefresh();
 
-      // Access token should remain unchanged (undefined in this case)
+      // Access token should remain unchanged (null in this case)
       expect(auth.getAccessToken()).toBe(originalAccessToken);
     });
   });
@@ -301,58 +360,58 @@ describe('GameGlueAuth', () => {
     });
   });
 
-  describe('setTokenRefreshTimeout', () => {
+  describe('_setTokenRefreshTimeout', () => {
     it('should schedule refresh before token expiration', () => {
       // Token expires in 1 hour (3600 seconds)
-      auth.setTokenRefreshTimeout(validAccessToken);
+      auth._setTokenRefreshTimeout(validAccessToken);
 
       // Should have scheduled a timeout
       expect(jest.getTimerCount()).toBe(1);
     });
 
     it('should clear previous timeout when setting new one', () => {
-      auth.setTokenRefreshTimeout(validAccessToken);
-      auth.setTokenRefreshTimeout(validAccessToken);
+      auth._setTokenRefreshTimeout(validAccessToken);
+      auth._setTokenRefreshTimeout(validAccessToken);
 
       // Should only have one active timeout
       expect(jest.getTimerCount()).toBe(1);
     });
 
     it('should not schedule timeout for expired token', () => {
-      auth.setTokenRefreshTimeout(expiredAccessToken);
+      auth._setTokenRefreshTimeout(expiredAccessToken);
 
       // Timer count may be 0 since the timeUntilExp is negative
       // The important thing is it doesn't throw
     });
   });
 
-  describe('_shouldHandleRedirectResponse', () => {
+  describe('_hasCallbackParams', () => {
     it('should return true when hash contains state and code', () => {
       window.location.hash = '#state=abc123&code=xyz789';
 
-      expect(auth._shouldHandleRedirectResponse()).toBe(true);
+      expect(auth._hasCallbackParams()).toBe(true);
     });
 
     it('should return true when hash contains state and error', () => {
       window.location.hash = '#state=abc123&error=access_denied';
 
-      expect(auth._shouldHandleRedirectResponse()).toBe(true);
+      expect(auth._hasCallbackParams()).toBe(true);
     });
 
     it('should return false when hash does not contain state', () => {
       window.location.hash = '#code=xyz789';
 
-      expect(auth._shouldHandleRedirectResponse()).toBe(false);
+      expect(auth._hasCallbackParams()).toBe(false);
     });
 
     it('should return false when hash is empty', () => {
       window.location.hash = '';
 
-      expect(auth._shouldHandleRedirectResponse()).toBe(false);
+      expect(auth._hasCallbackParams()).toBe(false);
     });
   });
 
-  describe('handleRedirectResponse', () => {
+  describe('_processCallback', () => {
     it('should process signin response and store tokens', async () => {
       const { OidcClient } = require('oidc-client-ts');
       OidcClient.mockImplementation(() => ({
@@ -363,14 +422,14 @@ describe('GameGlueAuth', () => {
       }));
 
       const authNew = new GameGlueAuth(mockConfig);
-      await authNew.handleRedirectResponse();
+      await authNew._processCallback();
 
       expect(authNew.getAccessToken()).toBe(validAccessToken);
-      expect(authNew.getRefreshToken()).toBe(validRefreshToken);
-      expect(window.history.pushState).toHaveBeenCalled();
+      expect(authNew._getRefreshToken()).toBe(validRefreshToken);
+      expect(window.history.replaceState).toHaveBeenCalled();
     });
 
-    it('should handle error response gracefully', async () => {
+    it('should throw on error response', async () => {
       const { OidcClient } = require('oidc-client-ts');
       OidcClient.mockImplementation(() => ({
         processSigninResponse: jest.fn().mockResolvedValue({
@@ -380,12 +439,43 @@ describe('GameGlueAuth', () => {
       }));
 
       const authNew = new GameGlueAuth(mockConfig);
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
 
-      await authNew.handleRedirectResponse();
+      await expect(authNew._processCallback()).rejects.toThrow('access_denied');
+    });
+
+    it('should throw when no access token received', async () => {
+      const { OidcClient } = require('oidc-client-ts');
+      OidcClient.mockImplementation(() => ({
+        processSigninResponse: jest.fn().mockResolvedValue({
+          access_token: null
+        })
+      }));
+
+      const authNew = new GameGlueAuth(mockConfig);
+
+      await expect(authNew._processCallback()).rejects.toThrow('No access token received');
+    });
+
+    it('should handle concurrent calls (only process once)', async () => {
+      const { OidcClient } = require('oidc-client-ts');
+      const processSigninResponse = jest.fn().mockResolvedValue({
+        access_token: validAccessToken,
+        refresh_token: validRefreshToken
+      });
+      OidcClient.mockImplementation(() => ({
+        processSigninResponse
+      }));
+
+      const authNew = new GameGlueAuth(mockConfig);
+
+      // Call twice concurrently
+      await Promise.all([
+        authNew._processCallback(),
+        authNew._processCallback()
+      ]);
 
-      expect(consoleSpy).toHaveBeenCalledWith('access_denied');
-      consoleSpy.mockRestore();
+      // Should only have been called once due to locking
+      expect(processSigninResponse).toHaveBeenCalledTimes(1);
     });
   });
 });

package/src/index.js

@@ -1,74 +1,112 @@
 import { GameGlueAuth } from './auth';
 import { io } from "socket.io-client";
-import { Listener} from "./listener";
+import { Listener } from "./listener";
 
 const GAME_IDS = {
   'msfs': true,
 };
 
-class GameGlue extends GameGlueAuth  {
+const DEFAULT_SOCKET_URL = 'https://socks.gameglue.gg';
+
+class GameGlue extends GameGlueAuth {
   constructor(cfg) {
     super(cfg);
-    this._socket = false;
-  }
-  
-  async auth() {
-    await this.authenticate();
-    if (await this.isAuthenticated()) {
-      await this.initialize();
-    }
-    return this.getUserId();
-  }
-  
-  async initialize() {
-    return new Promise((resolve) => {
-      const token = this.getAccessToken();
-      // For local development, use 'http://localhost:3031'
-      this._socket = io('https://socks.gameglue.gg', {
-        transports: ['websocket'],
-        auth: {
-          token
-        }
-      });
-      // TODO: Update this code to use the new refresh logic. Example in gg-client repo
-      this._socket.on('connect', () => {
-        resolve();
-      });
-      this.onTokenRefreshed(this.updateSocketAuth);
-    });
-  }
-  
-  updateSocketAuth(authToken) {
-    this._socket.auth.token = authToken;
+    this._socket = null;
+    this._socketUrl = cfg.socketUrl || DEFAULT_SOCKET_URL;
+    this._connectPromise = null;
   }
-  
+
+  /**
+   * Create a listener for game telemetry.
+   * Connects to socket server lazily on first call.
+   * @param {Object} config - { userId, gameId, fields? }
+   * @returns {Promise<Listener>}
+   */
   async createListener(config) {
     if (!config) throw new Error('Not a valid listener config');
     if (!config.gameId || !GAME_IDS[config.gameId]) throw new Error('Not a valid Game ID');
     if (!config.userId) throw new Error('User ID not supplied');
     if (config.fields && !Array.isArray(config.fields)) throw new Error('fields must be an array');
 
-    // Ensure socket is initialized (handles page reload case)
-    if (!this._socket) {
-      await this.initialize();
-    }
+    // Ensure socket is connected (lazy initialization)
+    await this._ensureConnected();
 
     const listener = new Listener(this._socket, config);
     const establishConnectionResponse = await listener.establishConnection();
-    this._socket.io.on('reconnect_attempt', (d) => {
-      console.log('Refresh Attempt');
-      this.updateSocketAuth(this.getAccessToken());
+
+    // Handle reconnection
+    this._socket.io.on('reconnect_attempt', () => {
+      this._updateSocketAuth(this.getAccessToken());
     });
     this._socket.io.on('reconnect', () => {
       listener.establishConnection();
     });
-    
+
     if (establishConnectionResponse.status !== 'success') {
       throw new Error(`There was a problem setting up the listener. Reason: ${establishConnectionResponse.reason}`);
     }
-    
+
     return listener.setupEventListener();
   }
+
+  // ============ Internal Methods ============
+
+  async _ensureConnected() {
+    // Already connected
+    if (this._socket?.connected) {
+      return;
+    }
+
+    // Connection in progress - wait for it
+    if (this._connectPromise) {
+      await this._connectPromise;
+      return;
+    }
+
+    // Start new connection
+    this._connectPromise = this._connect();
+
+    try {
+      await this._connectPromise;
+    } finally {
+      this._connectPromise = null;
+    }
+  }
+
+  _connect() {
+    return new Promise((resolve, reject) => {
+      const token = this.getAccessToken();
+
+      if (!token) {
+        reject(new Error('Not authenticated - call isAuthenticated() first'));
+        return;
+      }
+
+      this._socket = io(this._socketUrl, {
+        transports: ['websocket'],
+        auth: { token }
+      });
+
+      this._socket.on('connect', () => {
+        resolve();
+      });
+
+      this._socket.on('connect_error', (err) => {
+        reject(new Error(`Socket connection failed: ${err.message}`));
+      });
+
+      // Update socket auth when token refreshes
+      this.onTokenRefreshed((newToken) => {
+        this._updateSocketAuth(newToken);
+      });
+    });
+  }
+
+  _updateSocketAuth(authToken) {
+    if (this._socket) {
+      this._socket.auth.token = authToken;
+    }
+  }
 }
 
 if (typeof window !== 'undefined') {
@@ -76,4 +114,4 @@ if (typeof window !== 'undefined') {
 }
 
 export default GameGlue;
-export { GameGlue };
+export { GameGlue };

package/src/listener.js

@@ -1,4 +1,4 @@
-const EventEmitter = require('event-emitter');
+import EventEmitter from 'event-emitter';
 
 export class Listener  {
   constructor(socket, config) {
@@ -39,7 +39,21 @@ export class Listener  {
   }
 
   setupEventListener() {
-    this._socket.on('update', this.emit.bind(this, 'update'));
+    this._socket.on('update', (payload) => {
+      // Apply client-side field filtering if fields are specified
+      if (this._fields && this._fields.length > 0 && payload?.data) {
+        const filteredData = {};
+        for (const field of this._fields) {
+          if (field in payload.data) {
+            filteredData[field] = payload.data[field];
+          }
+        }
+        this.emit('update', { ...payload, data: filteredData });
+      } else {
+        // No filtering - pass through full payload
+        this.emit('update', payload);
+      }
+    });
     return this;
   }