@subiz/wsclient 4.0.28 → 4.0.31

package/README.md

@@ -1,27 +1,30 @@
-# Subiz rtclient
+# Subiz wsclient
 
 This library implements subiz long polling protocol
 
 ## Method
+
 ### subscribe
-### onEvents
-### onInterrupted
+
+### onEvent
+
 ### stop
 
 ## Example
-```
+
+```js
 var Realtime = require('@subiz/wsclient')
 var realtime = new Realtime('https://realtime-0.subiz.net/', {
-  account_id: 'ac1234',
-  getAccessToken:()=> '333344',
-  user_mask: 'mask123'
+	account_id: 'ac1234',
+	getAccessToken: () => '333344',
+	user_mask: 'mask123',
 })
 
-realtime.onEvent(ev => console.log(ev))
-realtime.onInterrupted(() => console.log('some message may have been losted'))
+realtime.onEvent((ev) => console.log(ev))
 
 // subscribe events
-realtime.subscribe([ev1, ev2, ev3])
+await realtime.subscribe(['message_sent', 'user_info_updated'])
+console.log(realtime.getStatus()) // 'active'
 
 realtime.stop()
 ```

package/common.js

@@ -64,8 +64,8 @@ var xhrsend = function (method, url, body, cb) {
 	request.send(body)
 }
 
-// JSON.parse without exeption
-// return undefined when parsing invalid JSON string
+// JSON.parse without exception
+// return undefined when input is an invalid JSON
 function parseJSON(str) {
 	try {
 		return JSON.parse(str)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@subiz/wsclient",
-	"version": "4.0.28",
+	"version": "4.0.31",
 	"main": "realtime.js",
 	"scripts": {
 		"dev": "vite",
@@ -16,7 +16,7 @@
 	"description": "",
 	"devDependencies": {
 		"tape": "^5.9.0",
-		"vite": "^6.0.7",
+		"vite": "^6.3.3",
 		"vite-plugin-commonjs": "^0.10.4"
 	},
 	"dependencies": {

package/realtime.js

@@ -8,121 +8,174 @@ var {xhrsend, parseJSON, Pubsub} = require('./common.js')
 // as fast as possible through onEvents callback.
 //
 // It will try it best to keep the communication with the realtime
-// server. But if the user is offline for too long or her network can't
-// keep up with the incomming events (rarely happend with today
-// internet speed). The connection will be halt. Dead.
+// server. But if the user is offline for too long or the network can't
+// keep up with incomming events (rarely happend with today internet speed).
+// The connection will be killed. Dead.
 //
 // Once dead, onDead will be called. After that, the connection is
 // useless, all resources will be released.
 function Conn(apiUrl, credential, onDead, onEvents, callAPI, accid) {
 	callAPI = callAPI || xhrsend // allow hook
 	credential = credential || {}
-	// tell if connection is dead
-	var dead = false
 
 	var lastToken = ''
-	// kill force the connection to dead state
-	this.kill = function () {
-		dead = true
-	}
 	if (!accid) accid = ''
 
-	// long polling loop, polling will run sequentialy. Each polling will start right
-	// after the previous returned. In case of error, polling loop will pause based on
-	// exponential backoff algorithm. Polling loop will terminate if it encounter an
-	// un-retryable error
-	// the polling loop starts after the first subscribe call finished successfully
+	var is_dead = false // tell if the connection is dead
+	var is_polling_stuck = false // tell if we've having trouble doing /poll
+	var is_sub_stuck = false // tell if we've having trouble doing /subscribe
+
+	// The long polling loop runs sequentially, with each poll starting immediately
+	// after the previous one completes. If an error occurs, the loop will pause
+	// using an exponential backoff strategy. It will terminate if an unretryable
+	// error is encountered.
+	// The first loop begins after the first subscription call completes successfully
 	var polling = function (backoff) {
-		if (dead) return
+		if (is_dead) return
 		callAPI('get', apiUrl + 'poll?token=' + lastToken + '&account-id=' + accid, undefined, function (body, code) {
-			if (dead) return
-			if (retryable(code)) return setTimeout(polling, calcNextBackoff(backoff), backoff + 1)
+			if (is_dead) return
+			if (retryable(code)) {
+				is_polling_stuck = true
+				return setTimeout(polling, calcNextBackoff(backoff), backoff + 1)
+			}
+
 			if (code !== 200) {
 				// unretryable error, should kill
-				dead = true
-				return onDead('poll')
+				is_polling_stuck = true
+				return kill('poll')
 			}
 
 			// 200, success
+			is_polling_stuck = false
 			body = parseJSON(body) || {}
 			if (body.host) apiUrl = absUrl(body.host)
 
 			var seqToken = body.sequential_token
-			// the server returns a malform payload. We should retry and hope it heal soon
-			if (!seqToken) return setTimeout(polling, calcNextBackoff(backoff), backoff + 1)
+			// the server returns a malform payload. We should end
+			if (!seqToken) return kill('poll')
 			lastToken = seqToken
 			onEvents(body.events || [])
 			return polling(0)
 		})
 	}
 
-	var subQueue = flow.batch(50, 100, function (events) {
-		if (dead) return ['dead']
-		if (events.length <= 0) return []
-
-		var out = []
-		return flow
-			.loop(function () {
-				return new Promise(function (rs) {
-					var query = '?token=' + lastToken
-					credential.getAccessToken().then(function (access_token) {
-						if (credential.user_ref) query += '&user_ref=' + encodeURIComponent(credential.user_ref)
-						else if (credential.user_mask) query += '&user-mask=' + encodeURIComponent(credential.user_mask)
-						else if (access_token) query += '&access-token=' + access_token
-
-						let fullurl = apiUrl + 'subs' + query + '&account-id=' + encodeURIComponent(accid || credential.account_id)
-						callAPI('post', fullurl, JSON.stringify({events: events}), function (body, code) {
-							if (dead) {
-								out = repeat('dead', events.length)
-								return rs(false) // break loop
-							}
-
-							if (retryable(code)) return setTimeout(rs, 3000, true)
-							// unretryable error
-							if (code !== 200) {
-								// we are unable to start the communication with realtime server.
-								// Must notify the user by killing the connection
-								dead = true
-								onDead('subscribe', body, code)
-								out = repeat('dead', events.length)
-								return rs(false)
-							}
-
-							if (lastToken) return rs(false)
-
-							// first time sub, should grab the initial token
-							body = parseJSON(body) || {}
-							var initialToken = body.initial_token
-							// the server returns a malform payload. We should retry and hope it heal soon
-							if (!initialToken) return setTimeout(rs, 3000, true)
-							if (body.host) apiUrl = absUrl(body.host)
-
-							lastToken = initialToken
-							polling(0)
+	var subQueue = flow.batch(50, 100, function (topics) {
+		if (is_dead) return Promise.resolve(repeat('dead', topics.length))
+		if (topics.length <= 0) return Promise.resolve([])
+
+		var resolve
+		var promise = new Promise((rs) => {
+			resolve = rs
+		})
+
+		var done = false
+		setTimeout(function () {
+			if (!done && !is_dead) is_sub_stuck = true
+		}, 4000)
+
+		setTimeout(() => {
+			// too long, kill
+			if (done) return
+			done = true
+			resolve(repeat('dead', topics.length))
+			if (is_dead) return
+			kill('subs')
+		}, 60000)
+
+		flow.loop(function () {
+			return new Promise(function (rs) {
+				if (is_dead) {
+					resolve(repeat('dead', topics.length))
+					return rs(false) // break loop
+				}
+
+				var query = '?token=' + lastToken
+				credential.getAccessToken().then(function (access_token) {
+					if (is_dead) {
+						resolve(repeat('dead', topics.length))
+						return rs(false) // break loop
+					}
+
+					if (credential.user_ref) query += '&user_ref=' + encodeURIComponent(credential.user_ref)
+					else if (credential.user_mask) query += '&user-mask=' + encodeURIComponent(credential.user_mask)
+					else if (access_token) query += '&access-token=' + access_token
+
+					var fullurl = apiUrl + 'subs' + query + '&account-id=' + encodeURIComponent(accid || credential.account_id)
+					callAPI('post', fullurl, JSON.stringify({events: topics}), function (body, code) {
+						if (done) return
+						if (is_dead) {
+							resolve(repeat('dead', topics.length))
+							return rs(false) // break loop
+						}
+
+						if (retryable(code)) {
+							is_sub_stuck = true
+							return setTimeout(rs, 3000, true)
+						}
+
+						// unretryable error
+						if (code !== 200) {
+							// we are unable to start the communication with the realtime server.
+							// Must notify the user by killing the connection
+							kill('subs')
+							resolve(repeat('dead', topics.length))
 							return rs(false)
-						})
+						}
+						is_sub_stuck = false
+						done = true
+						if (lastToken) {
+							resolve(topics)
+							return rs(false)
+						}
+
+						// first time sub, should grab the initial token
+						body = parseJSON(body) || {}
+						var initialToken = body.initial_token
+						// the server returns a malform payload. We should end
+						if (!initialToken) {
+							kill('subs')
+							resolve(repeat('dead', topics.length))
+							return rs(false) // break loop
+						}
+
+						// learn new host
+						if (body.host) apiUrl = absUrl(body.host)
+
+						lastToken = initialToken
+						polling(0)
+						resolve(topics)
+						return rs(false) // to break the loop
 					})
 				})
 			})
-			.then(function () {
-				return out
-			})
+		})
+
+		return promise
 	})
 
 	// subscribe call /subs API to tell server that we are listening for those events
 	// this function may start polling loop if it hasn't been started yet
-	// Note: this function is not design to be thread safed so, do not call this
-	// function multiple times at once
+	// its safe to call this function multiple times
 	this.subscribe = subQueue.push.bind(subQueue)
+
+	this.getStatus = function () {
+		if (is_dead) return 'dead'
+		if (is_sub_stuck || is_polling_stuck) return 'connecting'
+		return 'active'
+	}
+
+	// kill force the connection to dead state
+	var kill = function (reason) {
+		is_dead = true
+		onDead(reason)
+	}
+	this.kill = kill
 }
 
-// Realtime is just a stronger Conn.
-// This class helps you subscribe and listen realtime event from the
+// Realtime helps you subscribe and listen realtime event from th
 // realtime server
-// additional features compare to conn:
-//   + auto recreate and resub if the last conn is dead
-//   + don't subscribe already subscribed events
-function Realtime(apiUrls, credential, callAPI, accid) {
+// Realtime is just a stronger Conn.
+function Realtime(apiUrls, credential, callAPI, accid, skipautoreconnect) {
 	if (typeof apiUrls === 'string' || apiUrls instanceof String) apiUrls = [apiUrls]
 	credential = credential || {}
 	if (!credential.getAccessToken) {
@@ -134,19 +187,13 @@ function Realtime(apiUrls, credential, callAPI, accid) {
 	var pubsub = new Pubsub()
 
 	// holds all topics that realtime must subscribed
-	// {
-	//   a: 'online',
-	//   b: 'offline',
-	//   c: 'connecting',
-	// }
 	var topics = {}
 
 	// stop the connection
-	var stop = false
 	this.stop = function () {
-		if (!conn || stop) return
-		stop = true
+		if (!conn) return
 		conn.kill()
+		conn = undefined
 		pubsub.emit('interrupted')
 	}
 
@@ -158,9 +205,13 @@ function Realtime(apiUrls, credential, callAPI, accid) {
 		return pubsub.on('interrupted', cb)
 	}
 
-	var conn
+	this.getStatus = function () {
+		if (!conn) return 'dead'
+		return conn.getStatus()
+	}
+
 	this.subscribe = function (events) {
-		if (stop) return Promise.resolve({})
+		if (!conn) return Promise.resolve({error: 'dead'})
 		if (typeof events === 'string') events = [events]
 		if (!Array.isArray(events)) return Promise.resolve({error: 'param should be an array or string'})
 
@@ -169,46 +220,46 @@ function Realtime(apiUrls, credential, callAPI, accid) {
 		for (var i = 0; i < events.length; i++) {
 			var topic = events[i]
 			if (!topic) continue
-			if (!topics[topic]) all.push(conn.subscribe(topic))
+			if (topics[topic]) continue
+			topics[topic] = true // mark so next time we wont subscribe this event (topic) again
+			all.push(conn.subscribe(topic))
 		}
 		if (all.length === 0) return Promise.resolve({})
-		return Promise.all(all).then(function (errs) {
-			for (var i = 0; i < errs.length; i++) if (errs[i]) return {error: errs[i]}
-			for (var j = 0; j < events.length; j++) topics[events[j]] = true
+		return Promise.all(all).then(function () {
+			if (!conn || conn.getStatus() == 'dead') return {error: 'dead'}
 			return {}
 		})
 	}
 
 	// reconnect make sure there is alway a Conn running in the background
 	// if the Conn is dead, it recreate a new one
-	var reconnect = function () {
-		if (stop) return
-		// reset subscribed topic
-		var allTopics = Object.keys(topics)
-		for (var i = 0; i < allTopics.length; i++) topics[allTopics[i]] = false
-
+	var conn
+	this.reconnect = function () {
 		var randomUrl = apiUrls[Math.floor(Math.random() * apiUrls.length)]
-		conn = new Conn(
+		if (conn) conn.kill() // kill old connection
+		let myconn = new Conn(
 			randomUrl,
 			credential,
 			function (code, body, status) {
-				if (stop) return
+				if (myconn != conn) return // outdated
 				pubsub.emit('interrupted', code, body, status)
-				setTimeout(reconnect, 2000) // reconnect and resubscribe after 2 sec
+				if (!skipautoreconnect) setTimeout(this.reconnect, 2000) // reconnect and resubscribe after 2 sec
 			},
-			function (topics) {
-				if (stop) return
-				for (var i = 0; i < topics.length; i++) pubsub.emit('event', topics[i])
+			function (events) {
+				if (myconn != conn) return
+				for (var i = 0; i < events.length; i++) pubsub.emit('event', events[i])
 			},
 			callAPI,
 			accid,
 		)
+		conn = myconn
 
+		var copyTopics = Object.keys(topics)
+		topics = {}
 		// resubscribe all subscribed events
-		var topicKeys = Object.keys(topics)
-		for (var i = 0; i < topicKeys.length; i++) conn.subscribe(topicKeys[i])
+		return this.subscribe(copyTopics)
 	}
-	reconnect()
+	this.reconnect()
 }
 
 // calcNextBackoff returns number of seconds we must wait

package/realtime.test.js

@@ -1,99 +1,291 @@
 var test = require('tape')
 var Realtime = require('./realtime.js')
 
-function makeMockServer(script) {
-	var i = -1
-	return (method, url, body, cb) => {
-		i++
-		script[i](method, url, body, cb)
+async function testScript(t, script) {
+	let events = []
+	let calls = []
+	var realtime = new Realtime(
+		'https://api5.subiz.com.vn/',
+		{user_mask: 'mask123'},
+		(method, url, body, cb) => {
+			calls.push({method, url, body, cb})
+		},
+		'acctest',
+		true,
+	)
+	realtime.onEvent((ev) => events.push(ev))
+
+	for (let stepi in script.steps) {
+		let step = script.steps[stepi]
+		if (step.type == 'status') {
+			t.equal(realtime.getStatus(), step.status, script.name + '[' + stepi + ']')
+			continue
+		}
+
+		if (step.type == 'subscribe') {
+			realtime.subscribe(step.topics)
+			continue
+		}
+
+		if (step.type == 'reconnect') {
+			realtime.reconnect()
+			continue
+		}
+
+		if (step.type == 'wait') {
+			await sleep(step.timeout)
+			continue
+		}
+
+		if (step.type == 'call') {
+			t.true(step.call_id != undefined) // must define call id in the script
+			let start = Date.now()
+			let timeout = step.timeout || 10_000
+			let istimeout
+			for (;;) {
+				if (Date.now() - start > timeout) {
+					istimeout = true
+					break
+				}
+				// wait util api is called
+				await sleep(100)
+				let call
+				for (let c = 0; c < calls.length; c++) {
+					if (!calls[c].call_id) {
+						call = calls[c]
+						break
+					}
+				}
+				if (!call) continue
+				call.call_id = step.call_id
+				const myUrl = new URL(call.url)
+
+				if (step.path) t.equal(myUrl.pathname, step.path)
+
+				if (step.method) t.equal(step.method, call.method)
+
+				if (step.query) {
+					for (var key of Object.keys(step.query)) {
+						t.equal(step.query[key], myUrl.searchParams.get(key), script.name)
+					}
+				}
+
+				if (step.body) {
+					let keys = Object.keys(step.body)
+					let callbody
+					if (call.body) callbody = JSON.parse(call.body)
+					for (var key of keys) {
+						t.equal(JSON.stringify(step.body[key]), JSON.stringify(callbody[key]))
+					}
+				}
+				break
+			}
+
+			t.true(!istimeout, script.name + ' ' + stepi + ' ' + JSON.stringify(step))
+			continue
+		}
+
+		if (step.type == 'response') {
+			let call
+			for (var c = 0; c < calls.length; c++) {
+				if (calls[c].call_id == step.call_id) {
+					call = calls[c]
+					break
+				}
+			}
+
+			t.true(call != undefined)
+			call.cb(JSON.stringify(step.body), step.code)
+			continue
+		}
+		t.true(false, script.name + '[' + stepi + ']=' + step.type)
+	}
+
+	// check events
+	let scriptevents = script.events || []
+	t.equal(events.length, scriptevents.length)
+	for (let i in events) {
+		t.equal(JSON.stringify(events[i]), JSON.stringify(scriptevents[i]))
 	}
+	realtime.stop()
 }
 
-test('realtime', async (t) => {
-	var callapi = makeMockServer([
-		async (method, url, body, cb) => {
-			// must first call sub and must attach user-mask in the query
-			t.equal(method, 'post')
-			t.true(url.indexOf('subs?') !== -1)
-			t.true(url.indexOf('user-mask=mask123') !== -1)
-			cb(`{"initial_token": "token0"}`, 200)
+test.only('realtime', async (t) => {
+	let scripts = [
+		{
+			name: 'starting status',
+			steps: [
+				{type: 'status', status: 'active'},
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '1', path: '/subs', method: 'post', body: {events: ['message_sent']}},
+				{type: 'wait', timeout: 5000},
+				{type: 'status', status: 'connecting'},
+				{type: 'wait', timeout: 60000},
+				{type: 'status', status: 'dead'},
+				{type: 'response', call_id: '1', body: {initial_token: 'aaaaaa'}, code: 200},
+				{type: 'status', status: 'dead'}, // dead must be dead
+			],
 		},
-		async (method, url, body, cb) => {
-			// start the poll and must attach initial token  in the query
-			t.equal(method, 'get')
-			t.true(url.indexOf('poll?') !== -1)
-			t.true(url.indexOf('token=token0') !== -1)
-			cb(`{"events": [], "sequential_token": "token1"}`, 200)
+		{
+			name: 'long subscribe',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '1', path: '/subs', method: 'post', body: {events: ['message_sent']}},
+				{type: 'wait', timeout: 5000},
+				{type: 'status', status: 'connecting'},
+				{type: 'wait', timeout: 3000},
+				{type: 'status', status: 'connecting'},
+				{type: 'response', call_id: '1', body: {initial_token: 'aaaaaa'}, code: 200},
+				{type: 'status', status: 'active'},
+			],
+			events: [],
 		},
-		async (method, url, body, cb) => {
-			// next poll must attach last received token
-			t.equal(method, 'get')
-			t.true(url.indexOf('poll?') !== -1)
-			t.true(url.indexOf('token=token1') !== -1)
-			realtime.stop()
-			cb(`{"events": [], "token": "-"}`, 200)
+		{
+			name: 'double subscribe -> do nothing',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '1', path: '/subs', method: 'post', body: {events: ['message_sent']}},
+				{type: 'response', call_id: '1', body: {initial_token: 'token1'}, code: 200},
+				{type: 'call', call_id: '2', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'subscribe', topics: ['message_sent', 'message_pong']},
+				{type: 'call', call_id: '3', path: '/subs', method: 'post', body: {events: ['message_pong']}},
+			],
 		},
-	])
-
-	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
-	var err = await realtime.subscribe(['message_pong'])
-	t.true(Object.keys(err).length === 0)
-})
-
-test('realtime subs when server down and then backup', async (t) => {
-	var callapi = makeMockServer([
-		async (method, url, body, cb) => {
-			// must first call sub and must attach user-mask in the query
-			t.equal(method, 'post')
-			t.true(url.indexOf('subs?') !== -1)
-			t.true(url.indexOf('user-mask=mask123') !== -1)
-			cb(`502 too busy`, 502)
+		{
+			name: 'polling unstable',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '1', path: '/subs', method: 'post', body: {events: ['message_sent']}},
+				{type: 'wait', timeout: 1000},
+				{type: 'response', call_id: '1', body: {initial_token: 'token1'}, code: 200},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '2', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'wait', timeout: 30000},
+				{type: 'response', call_id: '2', body: 'network disconnected', code: 0},
+				{type: 'status', status: 'connecting'},
+				{type: 'call', call_id: '3', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'wait', timeout: 30000},
+				{type: 'response', call_id: '3', body: '500 keep internal', code: 500},
+				// more than 60 sec without any data => dead
+				{type: 'status', status: 'connecting'},
+			],
 		},
-		async (method, url, body, cb) => {
-			// should retry
-			t.equal(method, 'post')
-			t.true(url.indexOf('subs?') !== -1)
-			t.true(url.indexOf('user-mask=mask123') !== -1)
-			cb(`502 still busy`, 502)
+		{
+			name: 'polling dead',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '1', path: '/subs', method: 'post', body: {events: ['message_sent']}},
+				{type: 'wait', timeout: 1000},
+				{type: 'response', call_id: '1', body: {initial_token: 'token1'}, code: 200},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '2', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'response', call_id: '2', body: '400 dead', code: 400},
+				{type: 'status', status: 'dead'},
+			],
 		},
-		async (method, url, body, cb) => {
-			// should retry
-			t.equal(method, 'post')
-			t.true(url.indexOf('subs?') !== -1)
-			t.true(url.indexOf('user-mask=mask123') !== -1)
-			cb(`{"initial_token": "token0"}`, 200)
+		{
+			name: 'basic',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{
+					type: 'call',
+					call_id: '1',
+					path: '/subs',
+					query: {'user-mask': 'mask123'},
+					method: 'post',
+					body: {events: ['message_sent']},
+				},
+				{type: 'response', call_id: '1', body: {initial_token: 'token1'}, code: 200},
+				{type: 'wait', timeout: 1000},
+				{type: 'call', call_id: '2', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'status', status: 'active'},
+				{type: 'wait', timeout: 3000},
+				{type: 'response', call_id: '2', body: {events: [{text: 'xin chao'}], sequential_token: 'token2'}, code: 200},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '3', path: '/poll', query: {token: 'token2'}, method: 'get'},
+			],
+			events: [{text: 'xin chao'}],
 		},
-		async (method, url, body, cb) => {
-			t.equal(method, 'get')
-			t.true(url.indexOf('poll?') !== -1)
-			t.true(url.indexOf('token=token0') !== -1)
-			realtime.stop()
-			cb(`{"events": [], "token": "-"}`, 200)
+		{
+			name: 'realtime subs when server down and then backup',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{
+					type: 'call',
+					call_id: '1',
+					path: '/subs',
+					method: 'post',
+					body: {events: ['message_sent']},
+				},
+				{type: 'wait', timeout: 1000},
+				{type: 'response', call_id: '1', body: '502 too busy', code: 502},
+				{
+					type: 'call',
+					call_id: '1.1',
+					path: '/subs',
+					method: 'post',
+					body: {events: ['message_sent']},
+				},
+				{type: 'status', status: 'connecting'},
+				{type: 'wait', timeout: 1000},
+				{type: 'response', call_id: '1.1', body: '502 still busy', code: 502},
+				{type: 'status', status: 'connecting'},
+				{type: 'wait', timeout: 1000},
+				{
+					type: 'call',
+					call_id: '1.2',
+					path: '/subs',
+					method: 'post',
+					body: {events: ['message_sent']},
+				},
+				{type: 'status', status: 'connecting'},
+				{type: 'response', call_id: '1.2', body: {initial_token: 'token1'}, code: 200},
+				{type: 'call', call_id: '2', path: '/poll', query: {token: 'token1'}, method: 'get'},
+				{type: 'status', status: 'active'},
+				{type: 'wait', timeout: 3000},
+				{type: 'response', call_id: '2', body: {events: [{text: 'xin chao'}], sequential_token: 'token2'}, code: 200},
+				{type: 'status', status: 'active'},
+				{type: 'call', call_id: '3', path: '/poll', query: {token: 'token2'}, method: 'get'},
+			],
+			events: [{text: 'xin chao'}],
 		},
-	])
+		{
+			name: 'realtime must stop if there is something wrong with our credential or our code',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'call', call_id: 1, path: '/subs'},
+				{type: 'response', call_id: 1, body: '400 invalid mask', code: 400},
+				{type: 'status', status: 'dead'},
+			],
+		},
+		{
+			name: 'reconect',
+			steps: [
+				{type: 'subscribe', topics: ['message_sent']},
+				{type: 'call', call_id: 1, path: '/subs'},
+				{type: 'response', call_id: 1, body: '400 invalid mask', code: 400},
+				{type: 'status', status: 'dead'},
+				{type: 'reconnect'},
+				{type: 'wait', timeout: 1000},
+				{type: 'call', call_id: 2, path: '/subs'},
+				{type: 'wait', timeout: 1000},
+				{type: 'response', call_id: 2, body: {initial_token: 'token1'}, code: 200},
+				{type: 'status', status: 'active'},
+			],
+		},
+	]
 
-	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
-	var err = await realtime.subscribe(['message_pong'])
-	t.true(Object.keys(err).length === 0)
+	let ps = []
+	for (const script of scripts) {
+		// if (script.name != 'double subscribe -> do nothing') continue
+		ps.push(testScript(t, script))
+	}
+	await Promise.all(ps)
 })
 
-test('realtime must stop if there is something wrong with our credential or our code', async (t) => {
-	var subcode
-	var callapi = makeMockServer([
-		async (method, url, bkody, cb) => {
-			// must first call sub and must attach user-mask in the query
-			t.equal(method, 'post')
-			t.true(url.indexOf('subs?') !== -1)
-			t.true(url.indexOf('user-mask=mask123') !== -1)
-			cb(`400 invalid mask`, 400)
-			realtime.stop()
-		},
-	])
-
-	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
-	realtime.onInterrupted((_, _1, code) => {
-		subcode = code
-	})
-	var err = await realtime.subscribe(['message_pong'])
-	t.false(Object.keys(err).length === 0)
-})
+let sleep = (ms) => new Promise((rs) => setTimeout(rs, ms))

package/demo.html

@@ -1,129 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link
-      rel="stylesheet"
-      href="https://cdn.jsdelivr.net/npm/bootstrap@4.3.1/dist/css/bootstrap.min.css"
-    />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Subiz WebPhone Demo</title>
-    <style>
-      #info {
-        background: whitesmoke;
-        border-radius: 5px;
-      }
-      label {
-        font-weight: 600;
-        margin-right: 10px;
-      }
-      .info_line {
-        display: flex;
-        align-items: flex-start;
-      }
-    </style>
-  </head>
-  <body class="container pt-3">
-    <img
-      width="80"
-      src="https://storage.googleapis.com/sbz-email/images/d009afe944c1948998544e103ab0fef2_logo.png"
-    />
-    <h1 class="mt-4">Subiz call demo</h1>
-    <button
-      class="btn btn-primary"
-      style="width: 120px"
-      id="btnHangup"
-      onClick="inputToken()"
-			>
-      Nhập token
-    </button>
-    <div id="tokenStatus" class="mt-2 text-danger">Chưa nhập token</div>
-
-    <div class="mt-3" style="width: 250px">
-      <div>
-        <label>Đầu số</label>
-        <input
-          class="form-control"
-          id="fromNumber"
-          type="text"
-          value="842473021368"
-        />
-      </div>
-      <div class="mt-3">
-        <label>Số khách</label>
-        <input
-          class="form-control"
-          placeholder="036..."
-          id="toNumber"
-          type="text"
-        />
-      </div>
-      <div class="mt-3">
-        <button
-          class="btn btn-success mr-3"
-          style="width: 150px"
-          id="btnCall"
-          disabled
-          onClick="makeCall()"
-        >
-          Gọi
-        </button>
-        <button
-          class="btn btn-outline-danger"
-          style="width: 79px"
-          id="btnHangup"
-          onClick="hangupCall()"
-        >
-          Ngắt
-        </button>
-      </div>
-    </div>
-    <h3 class="mt-4">Thông tin cuộc gọi</h3>
-    <div class="p-2" id="info">
-      <div class="info_line">
-        <label>Call ID:</label>
-        <div id="infoCallId"></div>
-      </div>
-      <div class="info_line">
-        <label>Conversation ID:</label>
-        <div id="infoConversationId"></div>
-      </div>
-      <div class="info_line">
-        <label>Ghi âm:</label>
-        <a href="#" id="infoRecordedUrl" target="_blank"></a>
-      </div>
-      <div class="info_line">
-        <label>Gọi từ số:</label>
-        <div id="infoFromNumber"></div>
-      </div>
-      <div class="info_line">
-        <label>Gọi đến số:</label>
-        <div id="infoToNumber"></div>
-      </div>
-      <div class="info_line">
-        <label>Trạng thái:</label>
-        <div id="infoStatus"></div>
-      </div>
-      <div class="info_line">
-        <label>Gọi lúc:</label>
-        <div id="infoCreated"></div>
-      </div>
-      <div class="info_line">
-        <label>Thời lượng (giây):</label>
-        <div id="infoDuration"></div>
-      </div>
-      <div class="info_line">
-        <label>Mã ngắt máy:</label>
-        <div id="infoHangupCode"></div>
-      </div>
-    </div>
-    <div class="mt-4">
-      <h3>Sự kiện realtime</h3>
-      <pre
-        style="padding: 10px 15px; border-radius: 5px; background: whitesmoke"
-        id="infoLog"
-      ></pre>
-    </div>
-    <script type="module" src="./demo.js"></script>
-  </body>
-</html>

package/demo.js

@@ -1,207 +0,0 @@
-const SubizWebPhone = require('./webphone.js')
-
-let webphone
-var mycallid = 'x'
-let accid
-let eventLogs = {}
-
-// setTokenStatus renders whether token is valid or invalid
-function setTokenStatus(me) {
-	let $tokenStatus = document.getElementById('tokenStatus')
-	if (me == 'loading') {
-		$tokenStatus.innerHTML = 'Đang kiểm tra'
-		$tokenStatus.classList.add('text-muted')
-		$tokenStatus.classList.remove('text-danger')
-		$tokenStatus.classList.remove('text-success')
-		return
-	}
-
-	if (!me || !me.account_id) {
-		$tokenStatus.innerHTML = 'Token rỗng hoặc không hợp lệ. Vui lòng nhập lại'
-		$tokenStatus.classList.remove('text-danger')
-		$tokenStatus.classList.remove('text-success')
-		$tokenStatus.classList.add('text-muted')
-		return
-	}
-
-	$tokenStatus.innerHTML = 'Token hợp lệ. Xin chào ' + me.fullname
-	$tokenStatus.classList.add('text-success')
-	$tokenStatus.classList.remove('text-danger')
-	$tokenStatus.classList.remove('text-muted')
-}
-
-function init() {
-	setTokenStatus('loading')
-	fetch(`https://api.subiz.com.vn/4.0/me?x-access-token=${access_token}`)
-		.then((response) => {
-			return response.json()
-		})
-		.then((me) => {
-			setTokenStatus(me)
-			if (!me || !me.account_id) return null
-			return me
-		})
-		.then((me) => {
-			if (!me) return
-			// save token
-			try {
-				webphone = new SubizWebPhone(access_token)
-				accid = access_token.split('_')[0]
-			} catch (e) {
-				alert('ERROR2: ' + e)
-				// setTimeout(main)
-				return
-			}
-
-			document.getElementById('btnCall').disabled = false
-
-			webphone.onEvent(function (ev) {
-				let call = ev.data.call_info
-				let callid = call.call_id
-				eventLogs[callid] = eventLogs[callid] || []
-				if (callid != mycallid) return
-				eventLogs[callid].push(ev)
-
-				// render log
-				let logM = eventLogs[callid]
-				if (logM) {
-					let log = logM
-						.map((ev) => {
-							return `${new Date(ev.created).toLocaleString()} | ${ev.type} | ${JSON.stringify(ev.data.call_info)}`
-						})
-						.join('\n')
-					document.getElementById('infoLog').innerHTML = log
-				}
-
-				if (call.status == 'dialing') {
-					document.getElementById('infoRecordedUrl').innerHTML = ''
-					document.getElementById('infoRecordedUrl').href = undefined
-					document.getElementById('info').style['background-color'] = '#fffed3'
-				}
-
-				if (call.status == 'active') {
-					document.getElementById('info').style['background-color'] = '#8cff6b'
-				}
-
-				if (call.status == 'ended' || !call.status) {
-					document.getElementById('info').style['background-color'] = '#ffc6c6'
-				}
-
-				if (call.status == 'ended' && ev.id) {
-					// from server, not fake
-					document.getElementById('infoRecordedUrl').innerHTML = 'Đang tải...'
-					document.getElementById('infoRecordedUrl').href = undefined
-
-					fetchRecordedUrl(callid).then((url) => {
-						if (url == 'unavailable') {
-							document.getElementById('infoRecordedUrl').innerHTML = 'Không khả dụng'
-							document.getElementById('infoRecordedUrl').href = undefined
-							return
-						}
-						document.getElementById('infoRecordedUrl').innerHTML = url
-						document.getElementById('infoRecordedUrl').href = url
-					})
-				}
-			})
-		})
-}
-
-// inputToken asks access token from the agent
-function inputToken() {
-	access_token = prompt('Vui lòng nhập access token')
-	localStorage.setItem('access_token', access_token)
-	if (access_token) init()
-}
-
-// fetchRecordedUrl attemps to get the recorded audio url
-// since we dont know when the file is uploaded, we must retry multiple times.
-// this code is only for demo purpose
-function fetchRecordedUrl(callid) {
-	// try maximum 4 times
-	return new Promise((rs) => {
-		fetchConversation(callid).then((convo) => {
-			if (convo.call.recorded_audio && convo.call.recorded_audio.url) {
-				return rs(convo.call.recorded_audio.url)
-			}
-			setTimeout(() => {
-				fetchConversation(callid).then((convo) => {
-					if (convo.call.recorded_audio && convo.call.recorded_audio.url) {
-						return rs(convo.call.recorded_audio.url)
-					}
-
-					setTimeout(() => {
-						fetchConversation(callid).then((convo) => {
-							if (convo.call.recorded_audio && convo.call.recorded_audio.url) {
-								return rs(convo.call.recorded_audio.url)
-							}
-
-							setTimeout(() => {
-								fetchConversation(callid).then((convo) => {
-									if (convo.call.recorded_audio && convo.call.recorded_audio.url) {
-										return rs(convo.call.recorded_audio.url)
-									}
-									rs('unavailable')
-								})
-							}, 4000)
-						})
-					}, 4000)
-				})
-			}, 4000)
-		})
-	})
-}
-
-// fetchConversation sends a request API to get the latest conversation
-function fetchConversation(callid) {
-	let call = webphone.getCall(callid)
-	if (!call) return Promise.resolve(null)
-	let convoid = call.conversation_id
-	if (!convoid) return Promise.resolve(null)
-	return fetch(
-		`https://api.subiz.com.vn/4.0/accounts/${accid}/conversations/${convoid}?x-access-token=${access_token}`,
-	).then((response) => {
-		return response.json()
-	})
-}
-
-function makeCall() {
-	if (!webphone) return
-	let fromNumber = document.getElementById('fromNumber').value
-	let toNumber = document.getElementById('toNumber').value
-	//webphone.makeCall(toNumber, fromNumber);
-
-	webphone.makeCall('0364821895', ['935022139843821727', '842473021368'])
-	mycallid = webphone.getCurrentCallId()
-}
-
-let access_token = localStorage.getItem('access_token')
-if (access_token) init()
-
-// update loop
-setInterval(function () {
-	if (!webphone) return
-	let call = webphone.getCall(mycallid)
-	if (!call) return
-	document.getElementById('infoCallId').innerHTML = call.call_id
-	document.getElementById('infoFromNumber').innerHTML = call.from_number
-	document.getElementById('infoConversationId').innerHTML = call.conversation_id
-	document.getElementById('infoToNumber').innerHTML = call.to_number
-	document.getElementById('infoStatus').innerHTML = call.status
-	document.getElementById('infoCreated').innerHTML = new Date(call.started).toLocaleString()
-	if (call.status == 'active')
-		document.getElementById('infoDuration').innerHTML = Math.floor((Date.now() - call.started) / 1000) || 0
-	else {
-		document.getElementById('infoDuration').innerHTML = Math.floor((call.ended - call.started) / 1000) || 0
-	}
-	if (call.hangup_code) document.getElementById('infoHangupCode').innerHTML = call.hangup_code
-}, 500)
-
-function hangupCall() {
-	if (!webphone) return
-	webphone.hangupCall(mycallid)
-}
-
-// expose to window so we can call it in HTML
-window.makeCall = makeCall
-window.hangupCall = hangupCall
-window.inputToken = inputToken