Add support for binary decoder in addition to json decoder

package.json

@@ -30,7 +30,6 @@
     "all": true
   },
   "keywords": [
-    "pusher",
     "async",
     "notifications",
     "websocket"
@@ -43,6 +42,7 @@
     "@types/pusher-js": "^4.2.0",
     "@types/sinon": "^5.0.3",
     "chai": "^4.2.0",
+    "fast-text-encoding": "^1.0.3",
     "fetch-mock": "^7.0.7",
     "mocha": "^5.2.0",
     "mocha-sonarqube-reporter": "^1.0.2",

src/async-client.ts

@@ -1,4 +1,5 @@
-import {Serializer} from "./serializer";
+import {JsonDecoder} from "./json-decoder";
+import {MessageDecoder} from "./serializer"
 import {ChannelMessage} from "./channel-message";
 import {RetryTimer} from "./retry-timer";
 
@@ -17,16 +18,16 @@ export class AsyncClient {
     private readonly heartbeatIntervalMs : number;
     private tearingDown : boolean = false;
     private reconnectTimer : RetryTimer;
+    private serializer: MessageDecoder = new JsonDecoder();
 
-    constructor(private config: AsyncConfig, private transport : any = null) {
+    constructor(private config: AsyncConfig, private readonly transport : any = null) {
         const intWindow = typeof window !== "undefined" ? window : null;
         this.transport = transport || intWindow['WebSocket'];
         this.heartbeatIntervalMs = config.heartbeat_interval || 750;
         this.reconnectTimer = new RetryTimer(() => this.teardown(() => this.connect()));
         this.actualToken = config.channel_secret;
     }
 
-
     public connect(){
         if (this.socket) return;
         this.socket = new this.transport(this.socketUrl());
@@ -58,7 +59,7 @@ export class AsyncClient {
     }
 
     private onSocketMessage(event) {
-        const message = Serializer.decode(event.data)
+        const message = this.serializer.decode(event)
         if (!this.isActive && message.event == "AuthOk"){
             this.isActive = true;
             console.log("#DBG5 change active to true!")
@@ -153,6 +154,10 @@ export class AsyncClient {
         return this.socket;
     }
 
+    public getDecoder() : MessageDecoder {
+        return this.serializer;
+    }
+
     private socketUrl() : string {
         return `${this.config.socket_url}?channel=${this.config.channel_ref}`;
     }
@@ -205,6 +210,7 @@ export interface AsyncConfig{
     socket_url: string;
     channel_ref:string;
     channel_secret: string;
+    only_json?: boolean;
     heartbeat_interval? : number;
 }
 

src/binary-decoder.ts

@@ -0,0 +1,47 @@
+/* The Binary serializer for encoding and decoding messages */
+
+
+import {ChannelMessage} from "./channel-message";
+import {MessageDecoder} from "./serializer";
+
+export class BinaryDecoder implements MessageDecoder {
+
+    private textDecoder : TextDecoder;
+
+    constructor() {
+        this.textDecoder = new TextDecoder();
+    }
+
+    public decode(messageEvent: MessageEvent): ChannelMessage {
+        const buffer: ArrayBuffer = messageEvent.data;
+        const view = new DataView(buffer)
+
+        const control = view.getUint8(0);
+        if (control != 255){
+            throw new Error('Invalid binary data; no control byte match')
+        }
+
+        const extractor: Extractor = new Extractor(this.textDecoder, buffer, 4);
+        const message_id = extractor.decodeChunk(view.getUint8(1));
+        const correlation_id = extractor.decodeChunk(view.getUint8(2));
+        const event = extractor.decodeChunk(view.getUint8(3));
+        const payload = extractor.decodeChunk(null);
+
+        return new ChannelMessage(message_id, event, correlation_id, payload);
+    }
+}
+
+class Extractor {
+    constructor(private readonly textDecoder : TextDecoder,
+                private readonly buffer: ArrayBuffer,
+                private offset: number) {
+    }
+
+    public decodeChunk(size: number) : string {
+        const endIndex = size ? this.offset + size : this.buffer.byteLength + 1;
+        const data = this.textDecoder.decode(this.buffer.slice(this.offset, endIndex));
+        this.offset = endIndex;
+        return data;
+    }
+}
+

src/json-decoder.ts

@@ -0,0 +1,14 @@
+/* The Json serializer for encoding and decoding messages */
+
+
+import {ChannelMessage} from "./channel-message";
+import {MessageDecoder} from "./serializer";
+
+export class JsonDecoder implements MessageDecoder {
+
+    public decode(messageEvent: MessageEvent): ChannelMessage {
+        const [message_id, correlation_id, event, payload] = JSON.parse(messageEvent.data);
+        return new ChannelMessage(message_id, event, correlation_id, payload);
+    }
+}
+

src/serializer.ts

@@ -3,18 +3,7 @@
 
 import {ChannelMessage} from "./channel-message";
 
-export class Serializer {
-
-    public static decode(rawPayload: string): ChannelMessage {
-        const [message_id, correlation_id, event, payload] = JSON.parse(rawPayload);
-        return new ChannelMessage(message_id, event, correlation_id, payload);
-    }
-
-    public static encode(message: ChannelMessage): string {
-        let payload = [
-            message.message_id, message.correlation_id, message.event, message.payload
-        ]
-        return JSON.stringify(payload);
-    }
+export interface MessageDecoder {
+    decode(event: MessageEvent) : ChannelMessage;
+    // encode(message: ChannelMessage): any;
 }
-

test/async-client.test.ts

@@ -4,6 +4,7 @@ import {AsyncClient} from "../src/async-client";
 import { WebSocket, Server } from 'mock-socket';
 
 import {ChannelMessage} from "../src/channel-message";
+import {JsonDecoder} from "../src/json-decoder";
 
 const assert = chai.assert;
 
@@ -250,3 +251,22 @@ describe('Refresh token Tests', () =>  {
     });
 
 });
+
+
+describe('Setup and configuration Tests', () =>  {
+
+    const baseConf = {
+        socket_url: "wss://reconnect.local:8985/socket",
+        channel_ref: "ab771f3434aaghjgr",
+        channel_secret: "secret234342432dsfghjikujyg1221"
+    };
+
+    it('Should use Json decoder when specified' , () => {
+        let config = {...baseConf,
+            only_json: true
+        };
+        let client : AsyncClient = new AsyncClient(config, WebSocket);
+        assert.instanceOf(client.getDecoder(), JsonDecoder);
+    });
+
+});

test/binary-serializer.test.ts

@@ -0,0 +1,67 @@
+import * as chai from 'chai';
+
+import {ChannelMessage} from "../src/channel-message";
+import {MessageDecoder} from "../src/serializer";
+import {MessageEvent} from "./support/event"
+import {BinaryDecoder} from "../src/binary-decoder";
+import "fast-text-encoding"
+
+const assert = chai.assert;
+describe('Binary Serializer Tests', function()  {
+
+    const serializer: MessageDecoder = new BinaryDecoder();
+
+    it('Should decode basic binary payload' , () => {
+
+        const data: ArrayBuffer = binaryData();
+        const event  = new MessageEvent('test', {
+            data : data
+        });
+
+        const message = serializer.decode(event);
+
+        assert.deepEqual(message, new ChannelMessage("message_id2", "event_name2", "correlation_id2", "message_data1"));
+    });
+
+    it('Should decode UTF-8 with special characters binary payload' , () => {
+        const plainPayload = "{\"strange_message: \"áéíóú@ñ&%$#!especíalç\", \"strange_message: \"áéíóú@ñ&%$#!especíal2ç\"}";
+        const data: ArrayBuffer = specialBinaryData();
+        const event  = new MessageEvent('test', {
+            data : data
+        });
+
+        const message = serializer.decode(event);
+
+        assert.deepEqual(message, new ChannelMessage("message_id2", "event_name2", "correlation_id2", plainPayload));
+    });
+
+});
+
+/*
+  message_id: "message_id2",
+  correlation_id: "correlation_id2",
+  message_data: "message_data1",
+  event_name: "event_name2"
+*/
+function binaryData() : ArrayBuffer {
+    const rawData = [255, 11, 15, 11, 109, 101, 115, 115, 97, 103, 101, 95, 105, 100, 50, 99, 111,
+        114, 114, 101, 108, 97, 116, 105, 111, 110, 95, 105, 100, 50, 101, 118, 101,
+        110, 116, 95, 110, 97, 109, 101, 50, 109, 101, 115, 115, 97, 103, 101, 95,
+        100, 97, 116, 97, 49];
+    const byteArray = new Uint8Array(rawData);
+    return byteArray.buffer;
+}
+
+function specialBinaryData() : ArrayBuffer {
+    const rawData = [255, 11, 15, 11, 109, 101, 115, 115, 97, 103, 101, 95, 105, 100, 50, 99, 111,
+        114, 114, 101, 108, 97, 116, 105, 111, 110, 95, 105, 100, 50, 101, 118, 101,
+        110, 116, 95, 110, 97, 109, 101, 50, 123, 34, 115, 116, 114, 97, 110, 103,
+        101, 95, 109, 101, 115, 115, 97, 103, 101, 58, 32, 34, 195, 161, 195, 169,
+        195, 173, 195, 179, 195, 186, 64, 195, 177, 38, 37, 36, 35, 33, 101, 115, 112,
+        101, 99, 195, 173, 97, 108, 195, 167, 34, 44, 32, 34, 115, 116, 114, 97, 110,
+        103, 101, 95, 109, 101, 115, 115, 97, 103, 101, 58, 32, 34, 195, 161, 195,
+        169, 195, 173, 195, 179, 195, 186, 64, 195, 177, 38, 37, 36, 35, 33, 101, 115,
+        112, 101, 99, 195, 173, 97, 108, 50, 195, 167, 34, 125];
+    const byteArray = new Uint8Array(rawData);
+    return byteArray.buffer;
+}

test/json-serializer.test.ts

@@ -0,0 +1,23 @@
+import * as chai from 'chai';
+
+import {JsonDecoder} from "../src/json-decoder";
+import {ChannelMessage} from "../src/channel-message";
+import {MessageDecoder} from "../src/serializer";
+import {MessageEvent} from "./support/event"
+
+const assert = chai.assert;
+describe('Json Serializer Tests', function()  {
+
+    const serializer: MessageDecoder = new JsonDecoder()
+
+    it('Should decode basic string payload' , () => {
+        let payload = "[\"ids332msg1\", \"\", \"person.registered\", \"someData\"]";
+        // @ts-ignore
+        const event  = new MessageEvent('test', {
+            data : payload
+        });
+        const message = serializer.decode(event);
+        assert.deepEqual(message, new ChannelMessage("ids332msg1", "person.registered", "", "someData"));
+    });
+
+});