Merge pull request #1 from georgeboot/master

Adesin-fr · web-flow · commit 07771d8ceb4e · 2024-11-28T09:47:47.000+01:00
Merge georgeboot main
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -24,7 +24,7 @@ jobs:
       - run: yarn version --new-version ${{ github.event.release.tag_name }} --no-git-tag-version
       #      - run: yarn run build
       #      - run: yarn test
-      - run: yarn publish --access public --tag latest
+      - run: yarn publish --verbose --access public --tag latest
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
       - run: git add package.json
diff --git a/js-src/Websocket.ts b/js-src/Websocket.ts
@@ -1,19 +1,20 @@
 import { AxiosResponse } from "axios";
-import axios from 'axios';
 import { Channel } from "./Channel";
 
 export type Options = { authEndpoint: string, host: string, bearerToken: string, auth: any, debug: boolean };
 
 export type MessageBody = { event: string, channel?: string, data: object };
 
+const LOG_PREFIX = '[AG-WS]';
+
 export class Websocket {
     buffer: Array<object> = [];
 
     options: Options;
 
     websocket: WebSocket;
 
-    private listeners: { [channelName: string]: { [eventName: string]: Function } } = {}
+    private listeners: { [channelName: string]: { [eventName: string]: Function } } = {};
 
     private internalListeners: { [eventName: string]: Function } = {};
 
@@ -27,157 +28,162 @@ export class Websocket {
     private pingInterval: NodeJS.Timeout;
 
     private connect(host: string): void {
-        this.options.debug && console.log('Trying to connect...');
+        this.options.debug && console.log(LOG_PREFIX + ' Trying to connect...');
 
-        this.websocket = new WebSocket(host)
+        this.websocket = new WebSocket(host);
 
         this.websocket.onerror = () => {
+
             if (!this.hasConnected) {
+
                 setTimeout(() => {
-                    this.socketId = undefined
-                    this.connect(host)
+                    this.socketId = undefined;
+                    this.connect(host);
                 }, 3000);
             }
-        }
+        };
 
         this.websocket.onopen = () => {
-            this.options.debug && console.log('Connected !');
+            this.options.debug && console.log(LOG_PREFIX + ' Connected !');
             this.hasConnected = true;
+
             this.send({
                 event: 'whoami',
-            })
+            });
 
             while (this.buffer.length) {
-                const message = this.buffer[0]
+                const message = this.buffer[0];
 
-                this.send(message)
+                this.send(message);
 
-                this.buffer.splice(0, 1)
-            }
+                this.buffer.splice(0, 1);
+            };
 
             // Register events only once connected, or they won't be registered if connection failed/lost
 
             this.websocket.onmessage = (messageEvent: MessageEvent) => {
-                const message = this.parseMessage(messageEvent.data)
-                this.options.debug && console.log('onmessage', messageEvent.data)
+                const message = this.parseMessage(messageEvent.data);
+                this.options.debug && console.log(LOG_PREFIX + ' onmessage', messageEvent.data);
 
                 if (!message) {
-                    return
+                    return;
                 }
 
                 if (message.channel) {
-                    this.options.debug && console.log(`Received event ${message.event} on channel ${message.channel}`)
+                    this.options.debug && console.log(`${LOG_PREFIX} Received event ${message.event} on channel ${message.channel}`);
 
                     if (this.listeners[message.channel] && this.listeners[message.channel][message.event]) {
-                        this.listeners[message.channel][message.event](message.data)
+                        this.listeners[message.channel][message.event](message.data);
                     }
 
-                    return
+                    return;
                 }
 
                 if (this.internalListeners[message.event]) {
-                    this.internalListeners[message.event](message.data)
+                    this.internalListeners[message.event](message.data);
                 }
             }
 
 
             // send ping every 60 seconds to keep connection alive
             this.pingInterval = setInterval(() => {
                 if (this.websocket.readyState === this.websocket.OPEN) {
-                    this.options.debug && console.log('Sending ping')
+                    this.options.debug && console.log(LOG_PREFIX + ' Sending ping');
+
                     this.send({
                         event: 'ping',
-                    })
+                    });
                 }
-            }, 60 * 1000)
+            }, 60 * 1000);
         }
 
 
         this.websocket.onclose = () => {
             this.options.debug && console.info('Connection closed.');
+
             if (this.closing){
                 return;
             }
-            this.hasConnected = false
+
+            this.hasConnected = false;
             this.options.debug && console.info('Connection lost, reconnecting...');
+
             setTimeout(() => {
-                this.socketId = undefined
-                this.connect(host)
+                this.socketId = undefined;
+                this.connect(host);
             }, 1000);
         };
 
         this.on('whoami', ({ socket_id: socketId }) => {
-            this.socketId = socketId
+            this.socketId = socketId;
 
-            this.options.debug && console.log(`just set socketId to ${socketId}`)
+            this.options.debug && console.log(`${LOG_PREFIX} Just set socketId to ${socketId}`);
 
             // Handle the backlog and don't empty it, we'll need it if we lose connection
             let channel: Channel;
+
             for(channel of this.channelBacklog){
-                this.actuallySubscribe(channel)
+                this.actuallySubscribe(channel);
             }
-
-        })
-
-
+        });
     }
 
     constructor(options: Options) {
         this.options = options;
 
         this.connect(this.options.host);
 
-        return this
+        return this;
     }
 
     protected parseMessage(body: string): MessageBody {
         try {
-            return JSON.parse(body)
+            return JSON.parse(body);
         } catch (error) {
-            this.options.debug && console.error(error)
+            this.options.debug && console.error(error);
 
-            return undefined
+            return undefined;
         }
     }
 
     getSocketId(): string {
-        return this.socketId
+        return this.socketId;
     }
 
     private socketIsReady(): boolean {
-        return this.websocket.readyState === this.websocket.OPEN
+        return this.websocket.readyState === this.websocket.OPEN;
     }
 
     send(message: object): void {
         if (this.socketIsReady()) {
-            this.websocket.send(JSON.stringify(message))
-            return
+            this.websocket.send(JSON.stringify(message));
+            return;
         }
 
-        this.buffer.push(message)
+        this.buffer.push(message);
     }
 
     close(): void {
-        this.closing = true
-        this.internalListeners = {}
+        this.closing = true;
+        this.internalListeners = {};
 
-        clearInterval(this.pingInterval)
-        this.pingInterval = undefined
+        clearInterval(this.pingInterval);
+        this.pingInterval = undefined;
 
-        this.websocket.close()
+        this.websocket.close();
     }
 
     subscribe(channel: Channel): void {
         if (this.getSocketId()) {
-            this.actuallySubscribe(channel)
+            this.actuallySubscribe(channel);
         } else {
-            this.channelBacklog.push(channel)
+            this.channelBacklog.push(channel);
         }
     }
 
     private actuallySubscribe(channel: Channel): void {
         if (channel.name.startsWith('private-') || channel.name.startsWith('presence-')) {
-            this.options.debug && console.log(`Sending auth request for channel ${channel.name}`)
+            this.options.debug && console.log(`${LOG_PREFIX} Sending auth request for channel ${channel.name}`);
 
             if (this.options.bearerToken) {
                 this.options.auth.headers['Authorization'] = 'Bearer ' + this.options.bearerToken;
@@ -189,28 +195,28 @@ export class Websocket {
             }, {
               headers: this.options.auth.headers || {}
             }).then((response: AxiosResponse) => {
-                this.options.debug && console.log(`Subscribing to channels ${channel.name}`)
+                this.options.debug && console.log(`${LOG_PREFIX} Subscribing to private channel ${channel.name}`);
 
                 this.send({
                     event: 'subscribe',
                     data: {
                         channel: channel.name,
                         ...response.data
                     },
-                })
+                });
             }).catch((error) => {
-                this.options.debug && console.log(`Auth request for channel ${channel.name} failed`)
-                this.options.debug && console.error(error)
+                this.options.debug && console.log(`${LOG_PREFIX} Auth request for channel ${channel.name} failed`);
+                this.options.debug && console.error(error);
             })
         } else {
-            this.options.debug && console.log(`Subscribing to channels ${channel.name}`)
+            this.options.debug && console.log(`${LOG_PREFIX} Subscribing to channel ${channel.name}`);
 
             this.send({
                 event: 'subscribe',
                 data: {
                     channel: channel.name,
                 },
-            })
+            });
         }
     }
 
@@ -220,28 +226,28 @@ export class Websocket {
             data: {
                 channel: channel.name,
             },
-        })
+        });
 
         if (this.listeners[channel.name]) {
-            delete this.listeners[channel.name]
+            delete this.listeners[channel.name];
         }
     }
 
     on(event: string, callback: Function = null): void {
-        this.internalListeners[event] = callback
+        this.internalListeners[event] = callback;
     }
 
     bind(channel: Channel, event: string, callback: Function): void {
         if (!this.listeners[channel.name]) {
-            this.listeners[channel.name] = {}
+            this.listeners[channel.name] = {};
         }
 
-        this.listeners[channel.name][event] = callback
+        this.listeners[channel.name][event] = callback;
     }
 
     unbindEvent(channel: Channel, event: string, callback: Function = null): void {
         if (this.internalListeners[event] && (callback === null || this.internalListeners[event] === callback)) {
-            delete this.internalListeners[event]
+            delete this.internalListeners[event];
         }
     }
 }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "laravel-echo-api-gateway",
-    "version": "0.1.2",
+    "version": "0.5.2",
     "description": "Use Laravel Echo with API Gateway Websockets",
     "keywords": [
         "laravel",
@@ -49,6 +49,7 @@
         "jest": "^24.9.0",
         "jest-websocket-mock": "^2.2.0",
         "laravel-echo": "^1.10.0",
+        "mock-socket": "^9.0.3",
         "rollup": "^2.10.2",
         "rollup-plugin-typescript2": "^0.27.1",
         "standard-version": "^8.0.1",
diff --git a/yarn.lock b/yarn.lock
