u8-mqtt 0.4.0 → 0.5.0

package/code/base.jsy

@@ -9,28 +9,34 @@ export class MQTTError extends Error ::
 
 export class MQTTBase ::
   constructor(opt={}) ::
+    this.with(opt)
     this._conn_ = _mqtt_conn @ this,
       this._init_dispatch(opt, this)
 
+  with(fns_ns) ::
+    for let [k,v] of Object.entries(fns_ns) ::
+      if 'function' === typeof v :: this[k] = v
+    return this
+
   async conn_emit(evt, arg, err_arg) ::
     this.log_conn?.(evt, arg, err_arg)
     try ::
-      let fn_evt = this[await evt] // microtask break
+      let fn_evt = this[await evt] // microtask break using `await evt`
       if fn_evt ::
         await fn_evt.call(this, this, arg, err_arg)
-      else if err_arg ::
-        await this.on_error(err_arg, evt)
+      else if err_arg :: throw err_arg
     catch err ::
       this.on_error(err, evt)
 
-  on_error(err, err_path) ::
-    console.warn @ '[[u8-mqtt error: %s]]', err_path, err
+  on_error(err, evt) ::
+    console.warn @ '[[u8-mqtt error: %s]]', evt, err
 
   // Handshaking Packets
 
   async connect(pkt={}) ::
-    let cid = pkt.client_id || ['u8-mqtt--', '']
-    if Array.isArray(cid) ::
+    let cid = pkt.client_id || this.client_id
+    if 'string' !== typeof cid ::
+      // see init_client_id implementation in core.jsy
       pkt.client_id = cid = this.init_client_id(cid)
     this.client_id = cid
 
@@ -56,12 +62,13 @@ export class MQTTBase ::
     return this._send('auth', pkt, 'auth')
 
   ping() :: return this._send('pingreq', null, 'pingresp')
-
+  puback({pkt_id}) :: return this._send('puback', {pkt_id})
 
   // alias: sub
   subscribe(pkt, ex, topic_prefix) ::
     pkt = _as_topics(pkt, ex, topic_prefix)
-    return this._send('subscribe', pkt, pkt)
+    let suback = this._send('subscribe', pkt, pkt)
+    return this.on_sub?.(suback, pkt) ?? suback
 
   // alias: unsub
   unsubscribe(pkt, ex, topic_prefix) ::
@@ -69,48 +76,52 @@ export class MQTTBase ::
     return this._send('unsubscribe', pkt, pkt)
 
 
-  // alias: pub
-  publish(pkt, pub_opt) :: return _pub(this, pkt, pub_opt)
-  post(topic, payload, pub_opt) :: return _pub.m(this, topic, payload, pub_opt)
-  send(topic, payload, pub_opt) :: return _pub.mq(this, topic, payload, pub_opt)
-  store(topic, payload, pub_opt) :: return _pub.mqr(this, topic, payload, pub_opt)
-
-  json_post(topic, msg, pub_opt) :: return _pub.o(this, topic, msg, pub_opt)
-  json_send(topic, msg, pub_opt) :: return _pub.oq(this, topic, msg, pub_opt)
-  json_store(topic, msg, pub_opt) :: return _pub.oqr(this, topic, msg, pub_opt)
-
-  obj_post(topic, msg, pub_opt) :: return _pub.o(this, topic, msg, pub_opt)
-  obj_send(topic, msg, pub_opt) :: return _pub.oq(this, topic, msg, pub_opt)
-  obj_store(topic, msg, pub_opt) :: return _pub.oqr(this, topic, msg, pub_opt)
-
-
-
-  // Utility Methods
-
-  init_client_id(parts) ::
-    let cid = this.client_id
-
-    if undefined === cid ::
-      this.client_id = cid = (
-        #IF PLAT_WEB
-          this.sess_client_id(parts)
-        #ELSE
-          this.new_client_id(parts)
-        )
-
-    return cid
-
-  new_client_id(parts) ::
-    return [parts[0], Math.random().toString(36).slice(2), parts[1]].join('')
-
-  #IF PLAT_WEB
-    sess_client_id(parts) ::
-      let key = parts.join('\x20')
-      let cid = sessionStorage.getItem(key)
-      if null == cid ::
-        cid = this.new_client_id(parts)
-        sessionStorage.setItem(key, cid)
-      return cid
+  post(topic, payload, pub_opt) :: // qos:0
+    return this.pub({topic, payload, qos:0}, pub_opt)
+  send(topic, payload, pub_opt) :: // qos:1
+    return this.pub({topic, payload, qos:1}, pub_opt)
+  store(topic, payload, pub_opt) :: // qos:1, retain: 1
+    return this.pub({topic, payload, qos:1, retain: 1}, pub_opt)
+
+  // alias: json_post
+  obj_post(topic, msg, pub_opt) :: // qos:0
+    return this.pub({topic, msg, arg: 'msg', qos:0}, pub_opt)
+  // alias: json_send
+  obj_send(topic, msg, pub_opt) :: // qos:1
+    return this.pub({topic, msg, arg: 'msg', qos:1}, pub_opt)
+  // alias: json_store
+  obj_store(topic, msg, pub_opt) :: // qos:1, retain: 1
+    return this.pub({topic, msg, arg: 'msg', qos:1, retain: 1}, pub_opt)
+
+  // alias: publish -- because 'pub' is shorter for semantic aliases above
+  async pub(pkt, pub_opt) ::
+    if undefined === pkt.payload ::
+      if 'function' === typeof pub_opt ::
+        pub_opt = {fn_encode: pub_opt}
+
+      let {msg} = pkt
+      switch typeof msg ::
+        case 'function':
+          pub_opt = {...pub_opt, fn_encode: msg}
+          // flow into 'undefined' case
+        case 'undefined':
+          // return a single-value closure to publish packets
+          return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)
+
+      // Encode payload from msg; fn_encode allows alternative to JSON.stringify
+      let {fn_encode} = pub_opt || {}
+      pkt.payload = fn_encode
+        ? await fn_encode(msg)
+        : JSON.stringify(msg)
+
+    if pub_opt ::
+      if pub_opt.props ::
+        pkt.props = pub_opt.props
+      if pub_opt.xform ::
+        pkt = pub_opt.xform(pkt) || pkt
+
+    return this._send @ 'publish', pkt,
+      pkt.qos ? pkt : void 0 // key
 
 
   // Internal API
@@ -119,52 +130,24 @@ export class MQTTBase ::
 
   _init_dispatch(opt) ::
     this.constructor?._once_()
-    let router = this.router =
-      this._init_router?.(opt, this)
-
-    let tgt = @{}
-      __proto__: opt.on_mqtt_type || {}
-      router
-
-    tgt.mqtt_publish ||= router?.invoke
-    return _mqtt_dispatch(this, tgt)
+    let target = @{} __proto__: opt.on_mqtt_type
+    target.mqtt_publish ||=
+      this._init_router?.(opt, this, target)
+    return _mqtt_dispatch(this, target)
 
   static _aliases() ::
-    return ' pub:publish sub:subscribe unsub:unsubscribe '
+    return ' publish:pub sub:subscribe unsub:unsubscribe json_post:obj_post json_send:obj_send json_store:obj_store'
 
   static _once_(self=this) ::
     self._once_ = _=>0
-    self.MQTTError = MQTTError
     let p = self.prototype
+    p.MQTTError = MQTTError
     for let alias of self._aliases().split(/\s+/) ::
       alias = alias.split(':')
       let fn = alias[1] && p[alias[1]]
       if fn :: p[alias[0]] = fn
 
 
-/*
-on_mqtt_type = {
-  mqtt_auth(pkt, ctx) ::
-  mqtt_connect(pkt, ctx) ::
-  mqtt_connack(pkt, ctx) ::
-  mqtt_disconnect(pkt, ctx) ::
-
-  mqtt_publish(pkt, ctx)
-  mqtt_subscribe(pkt, ctx) ::
-  mqtt_unsubscribe(pkt, ctx) ::
-
-  mqtt_pingreq(pkt, ctx) ::
-  mqtt_pingresp(pkt, ctx) ::
-}
-*/
-
-
-const _prefix_topics = (topic_prefix, iterable) =>
-  Array.from @ iterable, value => @
-    value.trim // string
-      ? _prefix_topics(topic_prefix, value)
-      : topic_prefix + value
-
 function _as_topics(pkt, ex, topic_prefix) ::
   if ex?.trim :: // string
     topic_prefix = ex
@@ -181,53 +164,9 @@ function _as_topics(pkt, ex, topic_prefix) ::
   if topic_prefix ::
     // particularly useful with shared queues, e.g.
     //   topic_prefix = '$share/some-queue-name/'
-    pkt.topics = _prefix_topics(topic_prefix, pkt.topics)
-  return pkt
+    let _prefix_topics = v =>
+      v.trim ? topic_prefix+v : v.map(_prefix_topics)
 
-
-async function _pub(self, pkt, pub_opt) ::
-  if undefined === pkt.payload ::
-    if 'function' === typeof pub_opt ::
-      pub_opt = {fn_encode: pub_opt}
-
-    let {msg} = pkt
-    switch typeof msg ::
-      case 'function':
-        pub_opt = {...pub_opt, fn_encode: msg}
-        // flow into 'undefined' case
-      case 'undefined':
-        // return a single-value closure to publish packets
-        return v => _pub(self, {...pkt, [pkt.arg || 'payload']: v}, pub_opt)
-
-      default:
-        // Encode payload from msg; fn_encode allows alternative to JSON.stringify
-        let {fn_encode} = pub_opt || {}
-        pkt.payload = fn_encode
-          ? await fn_encode(msg)
-          : JSON.stringify(msg)
-
-  if pub_opt ::
-    if pub_opt.props ::
-      pkt.props = pub_opt.props
-    if pub_opt.xform ::
-      pkt = pub_opt.xform(pkt) || pkt
-
-  return self._send @ 'publish', pkt,
-    pkt.qos ? pkt : void 0 // key
-
-::
-  Object.assign @ _pub, @{}
-    m: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:0}, pub_opt)
-    mq: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:1}, pub_opt)
-    mqr: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:1, retain: 1}, pub_opt)
-
-    o: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:0}, pub_opt)
-    oq: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:1}, pub_opt)
-    oqr: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:1, retain: 1}, pub_opt)
+    pkt.topics = pkt.topics.map(_prefix_topics)
+  return pkt
 

package/code/core.jsy

@@ -12,20 +12,27 @@ const pkt_api = {
 }
 
 export class MQTTCore extends MQTTBase ::
-  constructor(opt={}) ::
-    super(opt)
-    this.with(opt)
-
   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
+
+  // automatic Client Id for connect()
+  init_client_id(parts=['u8-mqtt--','']) ::
+    let sess_stg=this.sess_stg
+    let key, cid = sess_stg?.getItem(key=parts.join(' '))
+    if ! cid ::
+      cid = parts.join @ Math.random().toString(36).slice(2)
+      sess_stg?.setItem(key, cid)
+    return cid
+
+  get sess_stg() :: return globalThis.sessionStorage
+
+
+  //on_error(err, evt) ::
+  //  console.warn @ '[[u8-mqtt error: %s]]', evt, err
 
   //log_conn(evt, arg, err_arg) ::
   //  console.info @ '[[u8-mqtt log: %s]]', evt, arg, err_arg
@@ -102,7 +109,6 @@ export class MQTTCore extends MQTTBase ::
   #IF PLAT_NODEJS
     with_tcp(...opt) ::
       opt = this._conn_opt(opt)
-      console.log @: opt
       return this._use_conn @=>
         this.with_stream @
           tcp_connect(opt)

package/code/router_path.jsy

@@ -10,17 +10,23 @@ export const with_topic_path_router = /* #__PURE__ */
 
 const mqtt_topic = topic_route =>
   topic_route
-    .replace(/[*].*$/, '#')
-    .replace(/:\w+\??/g, '+')
+    .replace @ /[*].*$/, '#'
+    .replace @ /:\w[^\/]*/g, '+'
 
-export const as_topic_path = topic_route => @
+/* From the [MQTT v5 Spec](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Topic_Names_and)
+4.7.1.2 Multi-level wildcard -- (‘#’ U+0023)
+... MUST be specified either on its own or following a topic level separator.
+In either case it MUST be the last character specified in the Topic Filter
+
+4.7.1.3 Single-level wildcard -- (‘+’ U+002B)
+...it MUST occupy an entire level of the filter.
+*/
+
+export const as_topic_path = (topic_route, id) => @
+  id=1,
   topic_route
-    .replace(/#$/, '*') // replace MQTT # wildcard at end
-    .split(/([^\/]*[+][^\/]*)/) // split on MQTT + match tokens
-    .reduce @\ sz, v, idx => sz + @
-      idx & 1 // even entires are body, odd are MQTT + tokens
-        ? `:$${1 + idx>>1}` // replace with `:$#` sequential ids, using ? for partial entries
-        : v // pass through body
+    .replace @ /#$/, '*' // replace MQTT '#' multi-level wildcard at end
+    .replace @ /\+/g, () => `:$${id++}` // replace MQTT '+' single-level wildcards
 
 function _ignore(pkt, params, ctx) :: ctx.done = true
 
@@ -35,9 +41,8 @@ function mqtt_topic_path_router() ::
       let priority = args.pop()
 
       if 'function' !== typeof fn ::
-        if false === fn ::
-          fn = _ignore
-        else throw new TypeError()
+        if fn :: throw new TypeError()
+        fn = _ignore
 
       let rte = _rxp_parse @ as_topic_path @ topic_route
 
@@ -53,7 +58,7 @@ function mqtt_topic_path_router() ::
     clear(priority) ::
       pri_lsts[priority ? 0 : 1] = []
       if null == priority ::
-        pri_lsts[1] = []
+        pri_lsts[1] = [] // null clears both lists
 
     async invoke(pkt, ctx) ::
       ctx.idx = 0
@@ -69,51 +74,33 @@ function mqtt_topic_path_router() ::
           break
         else ctx.idx++
 
-      let {pkt_id, qos} = pkt
-      if 1 === qos ::
-        await ctx.mqtt._send('puback', {pkt_id})
+      if 1 === pkt.qos ::
+        await ctx.mqtt.puback(pkt)
 
 
 function * _routes_iter(all_route_lists, topic) ::
+  topic = topic.replace(/^[\/]*/, '/') // ensure '/' prefix for regexparam library
   for let route_list of all_route_lists ::
-    for let route of route_list ::
-      let res = _route_match_one(topic, route)
-      if undefined !== res ::
-        yield res
-
-
-function _route_match_one(topic, {keys, pattern, tgt}) ::
-  let match = '/' !== topic[0]
-    ? pattern.exec('/'+topic)
-    : pattern.exec(topic)
-
-  if null === match ::
-    return
-
-  if false === keys ::
-    let {groups} = match
-    if ! groups ::
-      return [tgt]
-
-    let params = {}
-    for let k in groups ::
-      params[k] = groups[k]
-
-    return [tgt, params]
-
-  if 0 === keys.length ::
-    return [tgt]
-
-  let params = {}
-  for let i=0; i<keys.length; i++ ::
-    params[ keys[i] ] = match[1+i]
-  return [tgt, params]
+    for let {keys, pattern, tgt} of route_list ::
+      let match = pattern.exec(topic)
+      if match ::
+        let params = keys
+          ? keys.reduce @
+              (o, k, i) => (o[k] = match[1+i], o)
+              {}
+          : match.groups ?? match
+        yield [tgt, params]
 
 
 function _route_remove(all_route_lists, query) ::
-  let match = route => route===query || route.tgt===query || route.key===query
+  let fn_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)
+    let i = lst.findIndex(fn_match)
+    if 0 <= i ::
+      lst.splice(i,1)
+      return true
   return false
 

package/code/with_topic_router.jsy

@@ -14,28 +14,37 @@ export const with_topic_router = mqtt_topic_router =>
       return super._aliases() +
         ' sub_topic:subscribe_topic unsub_topic:unsubscribe_topic'
 
-    _init_router(opt) ::
-      return mqtt_topic_router(opt, this)
+    _init_router(opt, self, target) ::
+      this._subs = []
+      let router = this.router = target.router =
+        mqtt_topic_router(opt, this, target)
+      return router?.invoke
 
-    get on_topic() :: return this.router.add
-
-    _sub_chain(topic, ex, topic_prefix) ::
-      let res = this.subscribe @ [[ topic ]], ex, topic_prefix
-      let subs = this.subs || @ this.subs = new Map()
-      subs.set @ (res.topic = topic), (subs.last = res)
-      return this // fluent api -- return this and track side effects
+    on_sub(suback, pkt) ::
+      suback.pkt = pkt
+      this._subs.push(suback)
+      return suback
+    subs_settled() ::
+      return Promise.allSettled @
+        this._subs.splice(0,Infinity)
 
     // alias: sub_topic
     subscribe_topic(topic_route, ...args) ::
       let router = this.router
       router.add @ topic_route, true, args.pop() // handler
       let topic = router.mqtt_topic(topic_route)
-      return this._sub_chain @ topic, ...args // ex, topic_prefix
+      this.subscribe @ topic, ...args // ex, topic_prefix
+      return this // fluent api -- return this and track side effects
 
     // alias: unsub_topic
     unsubscribe_topic(topic_route, ...args) ::
       let router = this.router
       router.remove @ topic_route, true
       let topic = router.mqtt_topic(topic_route)
-      return this.unsubscribe @ [[ topic ]], ...args // topic_prefix
+      return this.unsubscribe @ topic, ...args // topic_prefix
+
+    // add topic handlers without corresponding subscribe packet
+    on_topic(...args) ::
+      this.router.add(...args)
+      return this