@cendarsoss/pusher-js 8.4.15 → 8.4.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cendarsoss/pusher-js",
-  "version": "8.4.15",
+  "version": "8.4.17",
   "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
   "types": "index.d.ts",
   "main": "dist/node/pusher.js",

package/src/core/connection/protocol/protocol.ts

@@ -40,15 +40,16 @@ const Protocol = {
       }
       // Copy sequence and conflation_key for delta compression
       // Server sends these as __delta_seq and __conflation_key
-      const sequence = messageData.__delta_seq ?? messageData.sequence;
-      const conflationKey =
-        messageData.__conflation_key ?? messageData.conflation_key;
+      const sequence = messageData.seq;
+      const conflationKey = messageData.conflation_key;
+
       if (typeof sequence === 'number') {
         (pusherEvent as any).sequence = sequence;
       }
       if (conflationKey !== undefined) {
         (pusherEvent as any).conflation_key = conflationKey;
       }
+      
       return pusherEvent;
     } catch (e) {
       throw { type: 'MessageParseError', error: e, data: messageEvent.data };

package/src/core/delta/manager.ts

@@ -285,22 +285,31 @@ export default class DeltaCompressionManager {
           '%',
       });
 
-      // Parse and return the reconstructed event
+      // Parse and return the reconstructed data payload
+      // reconstructedMessage is always a JSON string (from JSON.stringify),
+      // so we should always parse it before sending to event handlers
+      let reconstructedData: any;
       try {
-        const parsedMessage = JSON.parse(reconstructedMessage);
-        return {
-          event: event,
-          channel: channel,
-          data: parsedMessage.data || parsedMessage,
-        };
-      } catch (e) {
-        // If not JSON, return as-is
-        return {
-          event: event,
-          channel: channel,
-          data: reconstructedMessage,
-        };
+        reconstructedData = JSON.parse(JSON.parse(reconstructedMessage));
+      } catch (parseError) {
+        // This should not happen if the base message was valid JSON
+        // Log error but still return the data to avoid breaking the system
+        this.error('Failed to parse reconstructed message as JSON', {
+          channel,
+          event,
+          sequence,
+          parseError: (parseError as Error).message,
+          reconstructedMessageLength: reconstructedMessage.length,
+        });
+        // Return as string if parsing fails (fallback behavior)
+        reconstructedData = reconstructedMessage;
       }
+
+      return {
+        event: event,
+        channel: channel,
+        data: reconstructedData,
+      };
     } catch (error) {
       this.error('Delta decode failed', {
         channel,
@@ -327,14 +336,25 @@ export default class DeltaCompressionManager {
     sequence?: number,
     conflationKey?: string,
   ): void {
+    let parsedMessage: any;
+    try {
+      parsedMessage = JSON.parse(rawMessage);
+    } catch (e) {
+      this.log('handleFullMessage parse failed', {
+        channel,
+        hasSequence: sequence === 0 || !!sequence,
+      });
+      return;
+    }
+
     if (!sequence && sequence !== 0) {
       // Attempt to extract __delta_seq from payload when not provided separately
       try {
-        const parsed = JSON.parse(rawMessage);
         const candidate =
-          typeof parsed.data === 'string'
-            ? (JSON.parse(parsed.data).__delta_seq ?? parsed.__delta_seq)
-            : (parsed.data?.__delta_seq ?? parsed.__delta_seq);
+          typeof parsedMessage.data === 'string'
+            ? (JSON.parse(parsedMessage.data).__delta_seq ??
+              parsedMessage.__delta_seq)
+            : (parsedMessage.data?.__delta_seq ?? parsedMessage.__delta_seq);
         if (candidate === 0 || candidate) {
           sequence = candidate;
         } else {
@@ -353,7 +373,24 @@ export default class DeltaCompressionManager {
       }
     }
 
-    const messageSize = rawMessage.length;
+    if (parsedMessage?.data === undefined) {
+      this.log('handleFullMessage missing data field, skipping', {
+        channel,
+        hasSequence: sequence === 0 || !!sequence,
+      });
+      return;
+    }
+
+    const baseMessage = JSON.stringify(parsedMessage.data);
+    if (typeof baseMessage !== 'string') {
+      this.log('handleFullMessage base serialization failed, skipping', {
+        channel,
+        hasSequence: sequence === 0 || !!sequence,
+      });
+      return;
+    }
+
+    const messageSize = baseMessage.length;
 
     let channelState = this.channelStates.get(channel);
     if (!channelState) {
@@ -361,10 +398,6 @@ export default class DeltaCompressionManager {
       this.channelStates.set(channel, channelState);
     }
 
-    // The rawMessage is already stripped of __delta_seq and __conflation_key by pusher.ts
-    // We use it directly as the base - NO re-parsing/re-stringifying to preserve exact bytes
-    // (JSON.parse/stringify can change float representations which breaks delta checksums)
-
     // Use the provided conflationKey parameter (already extracted by pusher.ts from original message)
     const finalConflationKey = conflationKey;
 
@@ -376,7 +409,7 @@ export default class DeltaCompressionManager {
     if (channelState.conflationKey && finalConflationKey !== undefined) {
       channelState.updateConflationCache(
         finalConflationKey,
-        rawMessage, // Store raw message directly
+        baseMessage,
         sequence,
       );
       this.log('Stored full message (conflation)', {
@@ -386,7 +419,7 @@ export default class DeltaCompressionManager {
         size: messageSize,
       });
     } else {
-      channelState.setBase(rawMessage, sequence); // Store raw message directly
+      channelState.setBase(baseMessage, sequence);
       this.log('Stored full message', {
         channel,
         sequence,

package/src/core/pusher.ts

@@ -214,30 +214,12 @@ export default class Pusher {
             conflationKey = (event as any).conflation_key;
           }
 
-          // Use RAW message and strip metadata fields using REGEX
-          // This preserves exact byte representation (including float precision)
-          // We MUST NOT use JSON.parse/stringify as it can change float representations
-          let fullMessage = event.rawMessage || '';
-
-          if (fullMessage && sequence !== undefined) {
-            // Strip metadata fields using regex to preserve exact bytes
-            // Pattern matches: ,"__delta_seq":NUMBER or "__delta_seq":NUMBER, at start
-            fullMessage = fullMessage.replace(/,"__delta_seq":\d+/g, '');
-            fullMessage = fullMessage.replace(/"__delta_seq":\d+,/g, '');
-            // Pattern matches: ,"__conflation_key":"..." or "__conflation_key":"...", at start
-            fullMessage = fullMessage.replace(
-              /,"__conflation_key":"[^"]*"/g,
-              '',
-            );
-            fullMessage = fullMessage.replace(
-              /"__conflation_key":"[^"]*",/g,
-              '',
-            );
-          }
+          // Use RAW message as the canonical source for data-only base
+          const rawMessage = event.rawMessage || '';
 
           this.deltaCompression.handleFullMessage(
             event.channel,
-            fullMessage,
+            rawMessage,
             sequence,
             conflationKey,
           );