u8-mqtt 0.1.3 → 0.3.0

package/code/_conn.jsy

@@ -1,83 +1,82 @@
+import { ao_defer_v } from 'roap'
+export { ao_defer_v }
+
 export function _mqtt_conn(client, [on_mqtt, pkt_future]) ::
-  let q0 = _tiny_deferred_queue()
-  let q = _tiny_deferred_queue()
+  let _q_init = ao_defer_v(), _q_ready = ao_defer_v()
+  let _send_ready = async (...args) => (await _q_ready[0])(...args)
+  let _send_mqtt_pkt, _has_connected
+  client._send = _send_ready
 
-  let _asy_send = async (...args) =>
-    (await q)(...args)
-  let _send = client._send = _asy_send
+  return @{}
+    async when_ready() :: await _q_ready[0]
 
-  let _ping = () => client._send('pingreq')
-  let tid_ping, _is_set = false
+    ping: _ping_interval @=> _send_mqtt_pkt?.('pingreq')
 
-  return @{}
-    is_live: @=> _asy_send !== _send
-    is_set: @=> _is_set
+    reset(err) ::
+      if ! _send_mqtt_pkt :: return
 
-    reset() ::
-      tid_ping = clearInterval(tid_ping)
-      client._send = _send = _asy_send
-      _is_set = false
+      if err ::
+        _q_init[2](err)
 
-      // call client.on_reconnect in next promise microtask
-      _async_evt(client, client.on_reconnect)
+      _send_mqtt_pkt = null
+      _q_init = ao_defer_v()
+      client._send = _send_ready
 
-    ping(td) ::
-      tid_ping = clearInterval(tid_ping)
-      if td ::
-        tid_ping = setInterval(_ping, 1000 * td)
-        if tid_ping.unref ::
-          tid_ping.unref()
+      // call client.on_conn_reset in next promise microtask
+      client.conn_emit('on_disconnect', false===err, err)
 
     async send_connect(... args) ::
-      if _asy_send === _send ::
-        _send = await q0
+      if ! _send_mqtt_pkt ::
+        await _q_init[0] // _send_mqtt_pkt is set before fulfilled
 
       // await connack response
-      let res = await _send(...args)
+      let res = await _send_mqtt_pkt(...args)
+      if 0 == res[0].reason ::
+        _has_connected = true
+        // resolve _q_ready[0] with _send_mqtt_pkt closure
+        _q_ready[1](client._send = _send_mqtt_pkt)
+        _q_ready = ao_defer_v()
+        client.conn_emit('on_ready')
 
-      client._send = _send
-      q.notify(_send)
       return res
 
-    set(mqtt_session, send_u8_pkt) ::
-      _is_set = true
-
-      let [mqtt_decode, mqtt_encode] = mqtt_session
+    is_set: @=> !! _send_mqtt_pkt
+    set(mqtt_ctx, send_u8_pkt) ::
+      if _send_mqtt_pkt ::
+        throw new Error('Already connected')
 
+      mqtt_ctx = mqtt_ctx.mqtt_stream()
+      let sess_ctx = {mqtt: client}
       let on_mqtt_chunk = u8_buf =>
-        on_mqtt(
-          mqtt_decode(u8_buf),
-          {mqtt: client})
+        on_mqtt(mqtt_ctx.decode(u8_buf), sess_ctx)
 
-      _send = async (type, pkt, key) => ::
+      _send_mqtt_pkt = async (type, pkt, key) => ::
         let res = undefined !== key
           ? pkt_future(key) : true
 
         await send_u8_pkt @
-          mqtt_encode(type, pkt)
+          mqtt_ctx.encode_pkt(type, pkt)
 
         return res
 
-
-      q0.notify(_send)
+      _q_init[1](_send_mqtt_pkt) // resolve _q_init with _send_mqtt_pkt closure
 
       // call client.on_live in next promise microtask
-      _async_evt(client, client.on_live)
-
+      client.conn_emit('on_live', _has_connected)
       return on_mqtt_chunk
 
 
-async function _async_evt(obj, evt) {
-  // microtask break lookup
-  if (undefined !== evt) {
-    await evt.call(obj, await obj)
-  }
-}
-function _tiny_deferred_queue() {
-  let q = [] // tiny resetting deferred queue
-  q.then = y => { q.push(y) }
-  q.notify = v => {
-    for (let fn of q.splice(0,q.length))
-      fn(v) }
-  return q
-}
+function _ping_interval(send_ping) ::
+  let tid
+  return @\ td ::
+    tid = clearInterval(tid)
+    if td ::
+      tid = setInterval(send_ping, 1000 * td)
+      #IF PLAT_DENO
+        // ensure the interval allows the Deno event loop to exit
+        Deno.unrefTimer(tid)
+      #ELSE
+        // ensure the interval allows the NodeJS event loop to exit
+        tid.unref?.()
+      return true
+

package/code/_router.jsy

@@ -6,7 +6,7 @@ import {parse as _rxp_parse} from 'regexparam'
 function _ignore(pkt, params, ctx) :: ctx.done = true
 
 export function _mqtt_topic_router() ::
-  let pri_lsts = [[],[]]
+  let pri_lsts = [[],[]], rm = Symbol()
   let find = topic => _mqtt_routes_iter(pri_lsts, topic)
 
   return @{} find,
@@ -30,8 +30,7 @@ export function _mqtt_topic_router() ::
 
     remove(topic_route, priority) ::
       let lst = pri_lsts[priority ? 0 : 1]
-      lst = lst.filter @ e => e.key !== topic_route
-      pri_lsts[priority ? 0 : 1] = lst
+      return _mqtt_route_remove([lst], topic_route)
 
     clear(priority) ::
       pri_lsts[priority ? 0 : 1] = []
@@ -40,9 +39,13 @@ export function _mqtt_topic_router() ::
 
     async invoke(pkt, ctx) ::
       ctx.idx = 0
+      ctx.rm = rm
 
       for let [fn, params] of find(pkt.topic) ::
-        await fn(pkt, params, ctx)
+        let res = await fn(pkt, params, ctx)
+
+        if rm === res ::
+          _mqtt_route_remove(pri_lsts, fn)
 
         if ctx.done ::
           break
@@ -88,3 +91,11 @@ export function _mqtt_route_match_one(topic, {keys, pattern, tgt}) ::
     params[ keys[i] ] = match[1+i]
   return [tgt, params]
 
+
+export function _mqtt_route_remove(all_route_lists, query) ::
+  let match = route => route===query || route.tgt===query || route.key===query
+  for let lst of all_route_lists ::
+    let i = lst.findIndex(match)
+    if 0 <= i :: return !! lst.splice(i,1)
+  return false
+

package/code/base.jsy

@@ -2,20 +2,38 @@ import {_mqtt_conn} from './_conn.jsy'
 import {_mqtt_topic_router} from './_router.jsy'
 import {_mqtt_dispatch} from './_dispatch.jsy'
 
-export class MQTTBaseClient ::
+export class MQTTError extends Error ::
+  constructor(mqtt_pkt, reason=mqtt_pkt.reason) ::
+    super(`[0x${reason.toString(16)}] ${reason.reason}`)
+    this.mqtt_pkt = mqtt_pkt
+    this.reason = reason
+
+export class MQTTBase ::
   constructor(opt={}) ::
     this._conn_ = _mqtt_conn @ this,
       this._init_dispatch(opt, this)
 
+  async conn_emit(evt, arg, err_arg) ::
+    this.log_conn?.(evt, arg, err_arg)
+    try ::
+      let fn_evt = this[await evt] // microtask break
+      if fn_evt ::
+        await fn_evt.call(this, this, arg, err_arg)
+      else if err_arg ::
+        await this.on_error(err_arg, evt)
+    catch err ::
+      this.on_error(err, evt)
+
+  on_error(err, err_path) ::
+    console.warn @ '[[u8-mqtt error: %s]]', err_path, err
+
   // Handshaking Packets
 
   async connect(pkt={}) ::
-    let {client_id: cid} = pkt
-    if ! cid ::
-      pkt.client_id = cid = this.init_client_id(['u8-mqtt--', ''])
-    else if Array.isArray(cid) ::
+    let cid = pkt.client_id || ['u8-mqtt--', '']
+    if Array.isArray(cid) ::
       pkt.client_id = cid = this.init_client_id(cid)
-    else :: this.client_id = cid
+    this.client_id = cid
 
     if null == pkt.keep_alive ::
       pkt.keep_alive = 60
@@ -23,13 +41,16 @@ export class MQTTBaseClient ::
     let res = await this._conn_
       .send_connect('connect', pkt, 'connack')
 
+    if 0 != res[0].reason ::
+      throw new this.MQTTError(res[0])
+
     // TODO: merge with server's keep_alive frequency
     this._conn_.ping(pkt.keep_alive)
     return res
 
   async disconnect(pkt={}) ::
     let res = await this._send('disconnect', pkt)
-    this._conn_.reset()
+    this._conn_.reset(false)
     return res
 
   auth(pkt={}) ::
@@ -43,8 +64,9 @@ export class MQTTBaseClient ::
     pkt = _as_topics(pkt, ex)
     return this._send('subscribe', pkt, pkt)
   _sub_chain(topic, ex) ::
+    let res = this.subscribe @ [[ topic ]], ex
     let subs = this.subs || @ this.subs = new Map()
-    subs.set @ topic, this.subscribe @ [[ topic ]], ex
+    subs.set @ (res.topic = topic), (subs.last = res)
     return this // fluent api -- return this and track side effects
 
   // alias: unsub
@@ -122,7 +144,7 @@ export class MQTTBaseClient ::
 
   #IF PLAT_WEB
     sess_client_id(parts) ::
-      let key = `client_id ${parts.join('')}`
+      let key = parts.join('\x20')
       let cid = sessionStorage.getItem(key)
       if null == cid ::
         cid = this.new_client_id(parts)
@@ -138,21 +160,18 @@ export class MQTTBaseClient ::
     return this.router = _mqtt_topic_router(this)
 
   _init_dispatch(opt) ::
-    let router = this._init_router(opt, this)
-
     let tgt = @{}
       __proto__: opt.on_mqtt_type || {}
-      router
-
-    if ! tgt.mqtt_publish ::
-      tgt.mqtt_publish = router.invoke
+      router: this._init_router(opt, this)
 
+    tgt.mqtt_publish ||= tgt.router.invoke
     return _mqtt_dispatch(this, tgt)
 
 
 ::
-  let p = MQTTBaseClient.prototype
+  let p = MQTTBase.prototype
   Object.assign @ p, @{}
+    MQTTError
     pub: p.publish
     sub: p.subscribe
     unsub: p.unsubscribe

package/code/core.jsy

@@ -1,48 +1,70 @@
-import {MQTTBaseClient} from './base.jsy'
+import mqtt_pkt_ctx from 'u8-mqtt-packet/esm/codec_bind.js'
+import { MQTTBase } from './base.jsy'
 
 #IF PLAT_NODEJS
-  import {connect as tcp_connect} from 'net'
+  import {connect as tcp_connect} from 'node:net'
 
+const pkt_api = {
+  utf8(u8) { return new TextDecoder('utf-8').decode(u8 || this.payload ) },
+  json(u8) { return JSON.parse( this.utf8(u8) || null ) },
+  text(u8) { return this.utf8(u8) },
+}
 
-export class MQTTCoreClient extends MQTTBaseClient ::
-  static _with_session(mqtt_session) ::
-    this.prototype._mqtt_session = mqtt_session
-
+export class MQTTCore extends MQTTBase ::
   constructor(opt={}) ::
     super(opt)
-    this.with_live(opt.on_live)
-    this.with_reconnect(opt.on_reconnect)
-
+    this.with(opt)
 
-  // on_live(client) ::
-  with_live(on_live) ::
-    if on_live ::
-      this.on_live = on_live
+  static mqtt_ctx(mqtt_level, mqtt_opts, pkt_ctx=pkt_api) ::
+    let self = class extends this {}
+    self.prototype.mqtt_ctx =
+      mqtt_pkt_ctx(mqtt_level, mqtt_opts, pkt_ctx)
+    return self
 
+  with(fns_ns) ::
+    for let [k,v] of Object.entries(fns_ns) ::
+      if 'function' === typeof v :: this[k] = v
     return this
 
-  // on_reconnect(client) ::
-  with_reconnect(on_reconnect) ::
-    if on_reconnect ::
-      this.on_reconnect = on_reconnect
+  //log_conn(evt, arg, err_arg) ::
+  //console.info @ '[[u8-mqtt log: %s]]', evt, arg, err_arg
 
-      if ! this._conn_.is_set ::
-        on_reconnect(this)
+  on_live(client, is_reconnect) ::
+    if is_reconnect ::
+      return client.connect()
 
-    return this
+  //on_reconnect(client) ::
 
+  _use_conn(fn_reconnect) ::
+    return (this.reconnect = fn_reconnect)?.()
+  with_autoreconnect(opt=2000) ::
+    if opt.toFixed :: opt = @{} delay: opt
+    return this.with @:
+      on_reconnect() ::
+        this.delay(opt.delay || 2000)
+          .then(this.reconnect)
+          .then(opt.reconnect, opt.error)
+
+  on_disconnect(client, intentional) ::
+    if ! intentional ::
+      return client.on_reconnect?.()
+
+  delay(ms) ::
+    return new Promise @ done => setTimeout(done, ms)
 
   with_async_iter(async_iter, write_u8_pkt) ::
     let on_mqtt_chunk = this._conn_.set @
-      this._mqtt_session(),
+      this.mqtt_ctx,
       write_u8_pkt
 
     this._msg_loop = @!>
-      async_iter = await async_iter
-      for await (let chunk of async_iter)
-        on_mqtt_chunk(chunk)
-
-      this._conn_.reset()
+      try ::
+        async_iter = await async_iter
+        for await (let chunk of async_iter)
+          on_mqtt_chunk(chunk)
+        this._conn_.reset()
+      catch err ::
+        this._conn_.reset(err)
 
     return this
 
@@ -52,14 +74,15 @@ export class MQTTCoreClient extends MQTTBaseClient ::
       if !Number.isFinite(port) ::
         ({port, hostname} = new URL(port))
 
-      Deno.connect @:
-        port, hostname, transport: 'tcp'
-      .then @\ conn =>
+      return this._use_conn @::
+        let conn = Deno.connect @:
+          port, hostname, transport: 'tcp'
+
         this.with_async_iter @
-          Deno.iter(conn),
-          u8_pkt => conn.write(u8_pkt)
+          conn.then @ Deno.iter,
+          async u8_pkt => (await conn).write(u8_pkt)
 
-      return this
+        return this
 
 
   #IF PLAT_NODEJS
@@ -67,27 +90,25 @@ export class MQTTCoreClient extends MQTTBaseClient ::
       if !Number.isFinite(port) ::
         ({port, hostname} = new URL(port))
 
-      let sock = tcp_connect(port, hostname)
-      return this.with_stream(sock)
-
-
-  #IF HAS_STREAM
-    with_stream(read_stream, write_stream) ::
-      if undefined === write_stream ::
-        write_stream = read_stream
+      return this._use_conn @=>
+        this.with_stream @
+          tcp_connect(port, hostname)
 
-      return this.with_async_iter @ read_stream,
-        u8_pkt => write_stream.write(u8_pkt)
 
+  with_stream(read_stream, write_stream) ::
+    if undefined === write_stream ::
+      write_stream = read_stream
 
+    return this.with_async_iter @ read_stream,
+      u8_pkt => write_stream.write(u8_pkt)
 
 
   with_websock(websock) ::
-    if null == websock ::
-      websock = 'ws://127.0.0.1:9001'
-
-    if websock.origin || 'string' === typeof websock ::
-      websock = new WebSocket(new URL(websock), ['mqtt'])
+    if ! websock?.send ::
+      websock = new URL(websock || 'ws://127.0.0.1:9001')
+      return this._use_conn @=>
+        this.with_websock @
+          new WebSocket(websock, ['mqtt'])
 
     websock.binaryType = 'arraybuffer'
 
@@ -96,27 +117,25 @@ export class MQTTCoreClient extends MQTTBaseClient ::
       if 0 !== readyState ::
         throw new Error @ 'Invalid WebSocket readyState'
 
-      ready = new Promise( y =>
-        websock.addEventListener('open', y, {once: true}))
+      ready = new Promise @ fn => websock.onopen = fn
 
 
     let {_conn_} = this
     let on_mqtt_chunk = _conn_.set @
-      this._mqtt_session(),
+      this.mqtt_ctx,
       async u8_pkt => @
         await ready
         websock.send(u8_pkt)
 
-    websock.addEventListener @ 'close',
-      @::
-        delete websock.onmessage
-        _conn_.reset()
-
-      {once: true}
+    websock.onmessage = evt => @ on_mqtt_chunk @ new Uint8Array(evt.data)
+    websock.onclose = evt => ::
+      if ! evt.wasClean ::
+        var err = new Error('websocket connection close')
+        err.code = evt.code
+        err.reason = evt.reason
 
-    websock.onmessage = evt =>
-      on_mqtt_chunk @
-        new Uint8Array(evt.data)
+      _conn_.reset(err)
 
     return this
 
+export { MQTTCore as default }

package/code/index.mjs

@@ -1,7 +1,7 @@
-export {MQTTClient_v4, mqtt_v4, default} from './v4.mjs'
-export {MQTTClient_v5, mqtt_v5} from './v5.mjs'
-
-export * from './session.mjs'
+export {
+  MQTTClient_v5, mqtt_v5,
+  MQTTClient_v4, mqtt_v4, mqtt_v4 as default, // u8-mqtt-packet version 5 can also parse version 4 (3.1.1) packets
+} from './v5.mjs'
 
 export * from './core.jsy'
 export * from './base.jsy'

package/code/v4.mjs

@@ -1,11 +1,11 @@
-import {mqtt_session_ctx} from './session.mjs'
-import {MQTTCoreClient} from './core.jsy'
+import mqtt_opts_v4 from 'u8-mqtt-packet/esm/codec_v4_client.js'
+import MQTTCore from './core.jsy'
 
-class MQTTClient_v4 extends MQTTCoreClient {
-  _mqtt_session() { return mqtt_session_ctx(4)() }
-}
+const MQTTClient_v4 = /* #__PURE__ */
+  MQTTCore.mqtt_ctx(4, mqtt_opts_v4)
 
-const mqtt_v4 = opt => new MQTTClient_v4(opt)
+const mqtt_v4 = opt =>
+  new MQTTClient_v4(opt)
 
 export {
   MQTTClient_v4,

package/code/v5.mjs

@@ -1,16 +1,24 @@
-import {mqtt_session_ctx} from './session.mjs'
-import {MQTTCoreClient} from './core.jsy'
+import mqtt_opts_v5 from 'u8-mqtt-packet/esm/codec_v5_client.js'
+import MQTTCore from './core.jsy'
 
-class MQTTClient_v5 extends MQTTCoreClient {
-  _mqtt_session() { return mqtt_session_ctx(5)() }
-}
+const MQTTClient_v4 = /* #__PURE__ */
+  MQTTCore.mqtt_ctx(4, mqtt_opts_v5)
+
+const MQTTClient_v5 = /* #__PURE__ */
+  MQTTCore.mqtt_ctx(5, mqtt_opts_v5)
+
+const mqtt_v4 = opt =>
+  new MQTTClient_v4(opt)
 
-const mqtt_v5 = opt => new MQTTClient_v5(opt)
+const mqtt_v5 = opt =>
+  new MQTTClient_v5(opt)
 
 export {
+  MQTTClient_v4,
   MQTTClient_v5,
   MQTTClient_v5 as MQTTClient,
 
+  mqtt_v4,
   mqtt_v5,
   mqtt_v5 as mqtt,
   mqtt_v5 as default,