@subiz/wsclient 4.0.35 → 4.0.37

package/realtime.js

@@ -1,4 +1,3 @@
-var flow = require('@subiz/flow')
 var {xhrsend, parseJSON, Pubsub} = require('./common.js')
 
 // Conn represents a realtime connection between an user and the realtime
@@ -18,145 +17,215 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI, accid) {
 	callAPI = callAPI || xhrsend // allow hook
 	credential = credential || {}
 	var lastToken = ''
+	var lastAccessToken = ''
 	if (!accid) accid = ''
 	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 = true // 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 (is_dead) return
-		callAPI('get', apiUrl + 'poll?token=' + lastToken + '&v=5&account-id=' + accid, undefined, function (body, code) {
-			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
-				is_polling_stuck = true
-				return kill('poll')
+	// Server holds polls for at most 90s. Allow transport overhead, but recover
+	// before a request can hang forever. Custom transports may return an abort handle.
+	var POLL_TIMEOUT = 105000
+	var timers = new Set()
+	var requests = new Set()
+	var subscriptions = new Set()
+	function later(fn, delay) {
+		var timer = setTimeout(function () {
+			timers.delete(timer)
+			if (!is_dead) fn()
+		}, delay)
+		timers.add(timer)
+		return timer
+	}
+	function cancelTimer(timer) {
+		clearTimeout(timer)
+		timers.delete(timer)
+	}
+	function request(method, url, body, timeout, cb) {
+		var settled = false
+		var transport
+		function abort() {
+			try {
+				if (typeof transport === 'function') transport()
+				else if (transport && typeof transport.abort === 'function') transport.abort()
+			} catch (err) {
+				reportCallbackError(err)
 			}
+		}
+		function cancel() {
+			if (settled) return
+			settled = true
+			cancelTimer(timer)
+			requests.delete(cancel)
+			abort()
+		}
+		function complete(body, code) {
+			if (settled || is_dead) return
+			settled = true
+			cancelTimer(timer)
+			requests.delete(cancel)
+			cb(body, code)
+		}
+		requests.add(cancel)
+		var timer = later(function () {
+			cancel()
+			if (!is_dead) cb(undefined, -1)
+		}, timeout)
+		try {
+			transport = callAPI(method, url, body, complete)
+		} catch (err) {
+			complete(undefined, -1)
+		}
+		// A synchronous custom transport can stop the connection before returning.
+		if (is_dead) abort()
+	}
 
-			// 200, success
-			is_polling_stuck = false
-			body = parseJSON(body) || {}
-			if (body.host) apiUrl = absUrl(body.host)
+	var MIN_POLL_INTERVAL = 250
+	var polling_started = false
+	function startPolling() {
+		if (polling_started) return
+		polling_started = true
+		polling(0)
+	}
+	function polling(backoff) {
+		if (is_dead) return
+		var started = Date.now()
+		request(
+			'get',
+			apiUrl + 'poll?token=' + encodeURIComponent(lastToken) + '&v=5&account-id=' + encodeURIComponent(accid),
+			undefined,
+			POLL_TIMEOUT,
+			function (body, code) {
+				var wait = Math.max(0, MIN_POLL_INTERVAL - (Date.now() - started))
+				if (retryable(code)) {
+					is_polling_stuck = true
+					return later(
+						function () {
+							polling(backoff + 1)
+						},
+						Math.max(calcNextBackoff(backoff), wait),
+					)
+				}
+				if (code !== 200) {
+					is_polling_stuck = true
+					return kill('poll')
+				}
+				body = parseJSON(body) || {}
+				if (!body.sequential_token) return kill('poll')
+				is_polling_stuck = false
+				if (body.host) apiUrl = absUrl(body.host)
+				lastToken = body.sequential_token
+				onEvents(body.events || [])
+				if (!is_dead)
+					later(function () {
+						polling(0)
+					}, wait)
+			},
+		)
+	}
 
-			var seqToken = body.sequential_token
-			// the server returns a malform payload. We should end
-			if (!seqToken) return kill('poll')
-			lastToken = seqToken
-			onEvents(body.events || [])
-			return polling(0)
+	var pendingTopics = []
+	var batchTimer
+	var batchRunning = false
+	function scheduleBatch() {
+		if (is_dead || batchRunning || !pendingTopics.length) return
+		cancelTimer(batchTimer)
+		// Flush full queues early; smaller batches wait from their oldest topic.
+		var delay = pendingTopics.length > 50 ? 0 : Math.max(0, 100 - (Date.now() - pendingTopics[0].created))
+		batchTimer = later(flushBatch, delay)
+	}
+	function flushBatch() {
+		batchTimer = undefined
+		if (is_dead || batchRunning || !pendingTopics.length) return
+		batchRunning = true
+		var batch = pendingTopics.splice(0, 50)
+		function finish(results) {
+			batch.forEach(function (item, i) { item.resolve(results[i]) })
+			batchRunning = false
+			scheduleBatch()
+		}
+		subscribeBatch(batch.map(function (item) { return item.topic })).then(finish, function (err) {
+			reportCallbackError(err)
+			kill('subs')
+			finish(repeat('dead', batch.length))
 		})
 	}
-
-	var subQueue = flow.batch(50, 100, function (topics) {
+	function subscribeBatch(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
-			is_sub_stuck = 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 + '&v=5&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
+		if (!topics.length) return Promise.resolve([])
+		return new Promise(function (resolve) {
+			var done = false
+			function finish(result) {
+				if (done) return
+				done = true
+				cancelTimer(stuckTimer)
+				cancelTimer(deadline)
+				cancelTimer(retryTimer)
+				subscriptions.delete(cancel)
+				resolve(result)
+			}
+			function cancel() {
+				finish(repeat('dead', topics.length))
+			}
+			subscriptions.add(cancel)
+			var stuckTimer = later(function () {
+				is_sub_stuck = true
+			}, 4000)
+			var deadline = later(function () {
+				is_sub_stuck = true
+				kill('subs')
+			}, 60000)
+			var retryTimer
+			function retry() {
+				if (done || is_dead) return
+				is_sub_stuck = true
+				retryTimer = later(attempt, 3000)
+			}
+			function attempt() {
+				if (done || is_dead) return
+				Promise.resolve()
+					.then(function () {
+						return credential.getAccessToken()
 					})
-				})
-			})
+					.then(function (accessToken) {
+						if (done || is_dead) return
+						lastAccessToken = accessToken || ''
+						var query = '?token=' + encodeURIComponent(lastToken)
+						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 (accessToken) query += '&access-token=' + encodeURIComponent(accessToken)
+						var url = apiUrl + 'subs' + query + '&v=5&account-id=' + encodeURIComponent(accid || credential.account_id)
+						request('post', url, JSON.stringify({events: topics}), 60000, function (body, code) {
+							if (done || is_dead) return
+							if (retryable(code)) return retry()
+							if (code !== 200) return kill('subs')
+							if (!lastToken) {
+								body = parseJSON(body) || {}
+								if (!body.initial_token) return kill('subs')
+								if (body.host) apiUrl = absUrl(body.host)
+								lastToken = body.initial_token
+							}
+							is_sub_stuck = false
+							finish(topics)
+							startPolling()
+						})
+					})
+					.catch(retry)
+			}
+			attempt()
 		})
-
-		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
 	// its safe to call this function multiple times
-	this.subscribe = subQueue.push.bind(subQueue)
+	this.subscribe = function (topic) {
+		if (is_dead) return Promise.resolve('dead')
+		return new Promise(function (resolve) {
+			pendingTopics.push({topic, resolve, created: Date.now()})
+			scheduleBatch()
+		})
+	}
 
 	this.getStatus = function () {
 		if (is_dead) return 'dead'
@@ -164,9 +233,38 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI, accid) {
 		return 'active'
 	}
 
+	// Page exit cannot wait for credential refresh or a normal XHR response.
+	this.cleanup = function (browserWindow) {
+		if (is_dead || !lastToken) return
+		var url = apiUrl + 'cleanup?token=' + encodeURIComponent(lastToken) + '&account-id=' + encodeURIComponent(accid)
+		// Also support hosts where /rt goes through the standard API auth wrapper.
+		if (credential.user_ref) url += '&user_ref=' + encodeURIComponent(credential.user_ref)
+		else if (credential.user_mask) url += '&user-mask=' + encodeURIComponent(credential.user_mask)
+		else if (lastAccessToken) url += '&access-token=' + encodeURIComponent(lastAccessToken)
+		try {
+			if (browserWindow.navigator && typeof browserWindow.navigator.sendBeacon === 'function') {
+				if (browserWindow.navigator.sendBeacon(url)) return
+			}
+		} catch (e) {}
+		try {
+			if (typeof browserWindow.fetch === 'function') {
+				Promise.resolve(browserWindow.fetch(url, {method: 'POST', keepalive: true, credentials: 'include'})).catch(
+					function () {},
+				)
+			}
+		} catch (e) {}
+	}
+
 	// kill force the connection to dead state
 	var kill = function (reason) {
+		if (is_dead) return
 		is_dead = true
+		for (var timer of timers) clearTimeout(timer)
+		timers.clear()
+		for (var cancel of requests) cancel()
+		for (var finish of subscriptions) finish()
+		for (var item of pendingTopics) item.resolve('dead')
+		pendingTopics = []
 		onDead(reason)
 	}
 	this.kill = kill
@@ -184,16 +282,47 @@ function Realtime(apiUrls, credential, callAPI, accid, skipautoreconnect) {
 		}
 	}
 	if (!accid) accid = credential.account_id || ''
-	var pubsub = new Pubsub()
+	var pubsub = new Pubsub(reportCallbackError)
+	var reconnectTimer
+	var stopped = false
+	var leavingPage = false
+	var browserWindow =
+		typeof window !== 'undefined' &&
+		window.document &&
+		typeof window.addEventListener === 'function' &&
+		typeof window.removeEventListener === 'function'
+			? window
+			: undefined
+
+	var onPageHide = function (event) {
+		// A page saved in the back/forward cache may resume this connection.
+		if (event.persisted || leavingPage) return
+		leavingPage = true
+		clearTimeout(reconnectTimer)
+		reconnectTimer = undefined
+		browserWindow.removeEventListener('pagehide', onPageHide)
+		if (!conn) return
+		var oldconn = conn
+		conn = undefined
+		oldconn.cleanup(browserWindow)
+		oldconn.kill('pagehide')
+	}
 
 	// holds all topics that realtime must subscribed
 	var topics = {}
 
 	// stop the connection
 	this.stop = function () {
+		stopped = true
+		clearTimeout(reconnectTimer)
+		reconnectTimer = undefined
+		if (browserWindow) browserWindow.removeEventListener('pagehide', onPageHide)
 		if (!conn) return
-		conn.kill()
+		// detach before killing so onDead knows this is intentional and
+		// doesn't schedule a reconnect
+		var oldconn = conn
 		conn = undefined
+		oldconn.kill()
 		pubsub.emit('interrupted')
 	}
 
@@ -236,8 +365,20 @@ function Realtime(apiUrls, credential, callAPI, accid, skipautoreconnect) {
 	// if the Conn is dead, it recreate a new one
 	var conn
 	var reconnect = function () {
+		if (leavingPage) return Promise.resolve({error: 'dead'})
+		stopped = false
+		clearTimeout(reconnectTimer)
+		reconnectTimer = undefined
+		if (browserWindow) browserWindow.addEventListener('pagehide', onPageHide)
 		var randomUrl = apiUrls[Math.floor(Math.random() * apiUrls.length)]
-		if (conn) conn.kill() // kill old connection
+		if (conn) {
+			// detach before killing so the old conn's onDead doesn't
+			// schedule another reconnect (which would kill this new conn,
+			// schedule another one, and churn forever)
+			var oldconn = conn
+			conn = undefined
+			oldconn.kill()
+		}
 		var myconn = new Conn(
 			randomUrl,
 			credential,
@@ -245,7 +386,7 @@ function Realtime(apiUrls, credential, callAPI, accid, skipautoreconnect) {
 				if (conn === undefined || myconn != conn) return // outdated
 				conn = undefined // prevent dupplicate dead fire
 				pubsub.emit('interrupted', code, body, status)
-				if (!skipautoreconnect) setTimeout(reconnect, 2000) // reconnect and resubscribe after 2 sec
+				if (!skipautoreconnect && !stopped && !leavingPage) reconnectTimer = setTimeout(reconnect, 2000)
 			},
 			function (events) {
 				if (myconn != conn) return
@@ -298,4 +439,10 @@ function absUrl(url) {
 	return url
 }
 
+function reportCallbackError(err) {
+	try {
+		if (typeof console !== 'undefined' && console.error) console.error('Realtime callback failed:', err)
+	} catch (ignored) {}
+}
+
 module.exports = Realtime

package/webphone.js

@@ -1,9 +1,9 @@
-var {xhrsend, parseJSON, Pubsub, randomString} = require('./common.js')
+var {xhrsend, parseJSON, Pubsub, randomString, reportCallbackError} = require('./common.js')
 const WebRTCConn = require('./webrtc.js')
 var Realtime = require('./realtime.js')
 
 function WebPhone(access_token, realtime) {
-	var pubsub = new Pubsub()
+	var pubsub = new Pubsub(reportCallbackError)
 
 	var $audio = null
 	// chuẩn bị thẻ audio để nghe được
@@ -28,13 +28,18 @@ function WebPhone(access_token, realtime) {
 	if (!agid.startsWith('ag')) throw 'invalid_access_token'
 
 	if (!realtime)
-		realtime = new Realtime('https://api.subiz.com.vn/rt/0/', {
-			getAccessToken: function () {
-				return new Promise(function (rs) {
-					rs(access_token)
-				})
+		realtime = new Realtime(
+			'https://api.subiz.com.vn/rt/0/',
+			{
+				getAccessToken: function () {
+					return new Promise(function (rs) {
+						rs(access_token)
+					})
+				},
 			},
-		}, undefined, accid)
+			undefined,
+			accid,
+		)
 
 	var webrtcconn = new WebRTCConn({
 		accid: accid,
@@ -52,6 +57,7 @@ function WebPhone(access_token, realtime) {
 		},
 		onTrack: function (event) {
 			if (event.track.kind != 'audio') return
+			if (!$audio) return
 			$audio.srcObject = event.streams[0]
 		},
 	})
@@ -100,8 +106,8 @@ function WebPhone(access_token, realtime) {
 
 	var me = this
 	this.isMicAllowed = function () {
-		return me.checkMic().then(function (out) {
-			return out.result
+		return me.checkMic().result.then(function (stream) {
+			return !!stream
 		})
 	}
 
@@ -117,7 +123,7 @@ function WebPhone(access_token, realtime) {
 		var microPermission = getMicroPermissions()
 		return {
 			timeout: Promise.race([timeout, microPermission]),
-			result: getMicroPermissions(),
+			result: microPermission,
 		}
 	}
 
@@ -138,14 +144,9 @@ function WebPhone(access_token, realtime) {
 	}
 
 	this.answerWebCall = function (callid) {
-		return new Promise(function (rs) {
-			getMicroPermissions().then(function (stream) {
-				current_call_id = callid
-				webrtcconn.answerCall(callid, stream).then(function (out) {
-					if (out.error) return rs({error})
-					rs(body)
-				})
-			})
+		current_call_id = callid
+		return webrtcconn.answerCall(callid, getMicroPermissions()).then(function (out) {
+			return out.error ? {error: out.error} : out.body
 		})
 	}
 
@@ -158,12 +159,13 @@ function WebPhone(access_token, realtime) {
 	// makeCall(number, ['a','b','c'], streamPm) // fallback specific number
 	// makeCall(number, function() {}, streamPm) //
 	this.makeCall = function (number, fromnumbers, streamPm, _a, _b, _state) {
+		var ownsSource = !_state
 		if (!_state) _state = {}
 		if (!fromnumbers || (Array.isArray(fromnumbers) && fromnumbers.length == 0)) {
 			fromnumbers = _numbers
 		}
 
-		if (typeof fromnumbers === 'string' || fromnumbers instanceof String || typeof value === 'number') {
+		if (typeof fromnumbers === 'string' || fromnumbers instanceof String || typeof fromnumbers === 'number') {
 			fromnumbers = [fromnumbers + '']
 		}
 
@@ -172,11 +174,9 @@ function WebPhone(access_token, realtime) {
 		callid += `-${randomString(4, base)}-${randomString(12, base)}`
 		current_call_id = callid
 
-		if (!streamPm) streamPm = getMicroPermissions()
-
 		let callnumber = chooseCallNumber(fromnumbers, _state.called)
 		if (!callnumber)
-			return (
+			return Promise.resolve(
 				_state.last_result || {
 					start: Date.now(),
 					ended: Date.now(),
@@ -187,9 +187,13 @@ function WebPhone(access_token, realtime) {
 					id: callid,
 					hangup_code: 'failure',
 					status: 'ended',
-				}
+				},
 			)
-		return webrtcconn.makeCall(number, callnumber, streamPm, callid).then((out) => {
+		// Each attempt owns its clone. The source stays live across number fallback
+		// and is released once the complete dialing sequence finishes.
+		if (!_state.source) _state.source = Promise.resolve(streamPm || getMicroPermissions())
+		var attemptStream = _state.source.then((stream) => stream && stream.clone())
+		var result = webrtcconn.makeCall(number, callnumber, attemptStream, callid).then((out) => {
 			if (out.error) return out
 			if (out.hangup_code == 'cancel') return out
 			if (out.answered > 0) return out
@@ -198,10 +202,18 @@ function WebPhone(access_token, realtime) {
 				if (!_state.called) _state.called = {}
 				_state.called[callnumber] = true
 				_state.last_result = out
-				return this.makeCall(number, fromnumbers, streamPm, _a, _b, _state)
+				return me.makeCall(number, fromnumbers, streamPm, _a, _b, _state)
 			}
 			return out
 		})
+		if (!ownsSource) return result
+		return result.finally(() => {
+			_state.source
+				.then((stream) => {
+					if (stream) stream.getTracks().forEach((track) => track.stop())
+				}, reportCallbackError)
+				.catch(reportCallbackError)
+		})
 	}
 
 	var current_call_id = ''