mqtt-plus 1.4.7 → 1.4.8

package/CHANGELOG.md

@@ -2,7 +2,17 @@
 ChangeLog
 =========
 
-1.5.0 (2026-02-22)
+1.4.8 (2026-02-22)
+------------------
+
+- PERFORMANCE: cache encoder/decoder in encoding functions
+- BUGFIX: fix memory leak in destroy() for sink
+- BUGFIX: namespace timers of sink() and source() to avoid conflicts
+- BUGFIX: align event() share default with service/source/sink
+- CLEANUP: refactor RefCountedSubscription class to be redundancy-free
+- CLEANUP: various minor code cleanups (formatting, modernization)
+
+1.4.7 (2026-02-22)
 ------------------
 
 - IMPROVEMENT: provide a global "share" option

package/dst-stage1/mqtt-plus-auth.js

@@ -49,6 +49,10 @@ export class AuthTrait extends MetaTrait {
     async issue(payload) {
         if (this._credential === null)
             throw new Error("credential has to be provided before issuing tokens");
+        if (payload.roles.length === 0)
+            throw new Error("payload.roles must be a non-empty array");
+        if (payload.roles.length > 64)
+            throw new Error("payload.roles must not exceed 64 roles");
         const jwt = new SignJWT(payload);
         jwt.setProtectedHeader({ alg: "HS256", typ: "JWT" });
         const token = await jwt.sign(this._credential);

package/dst-stage1/mqtt-plus-codec.js

@@ -86,6 +86,8 @@ class Codec {
         if (this.format === "cbor") {
             if (!(data instanceof Uint8Array))
                 throw new Error("failed to decode CBOR format (data type is not Uint8Array)");
+            if (data.byteLength === 0)
+                throw new Error("failed to decode CBOR format (data is empty)");
             try {
                 result = CBOR.decode(data, { tags: this.tags });
             }
@@ -96,6 +98,8 @@ class Codec {
         else if (this.format === "json") {
             if (typeof data !== "string")
                 throw new Error("failed to decode JSON format (data type is not string)");
+            if (data.length === 0)
+                throw new Error("failed to decode JSON format (data is empty)");
             try {
                 result = JSONX.parse(data);
             }

package/dst-stage1/mqtt-plus-encode.d.ts

@@ -2,6 +2,8 @@ import { Buffer } from "node:buffer";
 import type { APISchema } from "./mqtt-plus-api";
 import { CodecTrait } from "./mqtt-plus-codec";
 export declare class EncodeTrait<T extends APISchema = APISchema> extends CodecTrait<T> {
+    private static encoder;
+    private static decoder;
     str2buf(data: string): Uint8Array;
     buf2str(data: Uint8Array): string;
     arr2buf(data: Buffer | Uint8Array | Int8Array): Uint8Array;

package/dst-stage1/mqtt-plus-encode.js

@@ -26,13 +26,16 @@ import { Buffer } from "node:buffer";
 import { CodecTrait } from "./mqtt-plus-codec";
 /*  encoding trait  */
 export class EncodeTrait extends CodecTrait {
+    /*  reusable encoder/decoder instances  */
+    static { this.encoder = new TextEncoder(); }
+    static { this.decoder = new TextDecoder(); }
     /*  convert character string to buffer  */
     str2buf(data) {
-        return new TextEncoder().encode(data);
+        return EncodeTrait.encoder.encode(data);
     }
     /*  convert buffer to character string  */
     buf2str(data) {
-        return new TextDecoder().decode(data);
+        return EncodeTrait.decoder.decode(data);
     }
     /*  convert byte-based typed array to buffer  */
     arr2buf(data) {

package/dst-stage1/mqtt-plus-event.js

@@ -31,14 +31,14 @@ export class EventTrait extends AuthTrait {
         let name;
         let callback;
         let options = {};
-        let share;
+        let share = this.options.share;
         let auth;
         if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
             /*  object-based API  */
             name = nameOrConfig.name;
             callback = nameOrConfig.callback;
             options = nameOrConfig.options ?? {};
-            share = nameOrConfig.share;
+            share = nameOrConfig.share ?? this.options.share;
             auth = nameOrConfig.auth;
         }
         else {
@@ -52,7 +52,7 @@ export class EventTrait extends AuthTrait {
         if (this.onRequest.has(`event-emission:${name}`))
             throw new Error(`event: event "${name}" already registered`);
         /*  generate the corresponding MQTT topics for broadcast and direct use  */
-        const topicS = share ? `$share/${share}/${name}` : name;
+        const topicS = share !== "" ? `$share/${share}/${name}` : name;
         const topicB = this.options.topicMake(topicS, "event-emission");
         const topicD = this.options.topicMake(name, "event-emission", this.options.id);
         /*  remember the registration  */

package/dst-stage1/mqtt-plus-meta.js

@@ -29,10 +29,11 @@ export class MetaTrait extends TimerTrait {
         /*  internal state  */
         this._meta = new Map();
     }
-    meta(key, value) {
-        if (key === undefined)
+    meta(...args) {
+        const [key, value] = args;
+        if (args.length === 0)
             return Object.fromEntries(this._meta);
-        else if (arguments.length === 1)
+        else if (args.length === 1)
             return this._meta.get(key);
         else if (value === undefined || value === null)
             this._meta.delete(key);

package/dst-stage1/mqtt-plus-sink.js

@@ -40,6 +40,8 @@ export class SinkTrait extends SourceTrait {
     async destroy() {
         for (const stream of this.pushStreams.values())
             stream.destroy();
+        for (const spool of this.pushSpools.values())
+            await spool.unroll();
         this.pushStreams.clear();
         this.pushSpools.clear();
         await super.destroy();
@@ -112,14 +114,15 @@ export class SinkTrait extends SourceTrait {
                     creditGranted: chunkCredit
                 } : undefined;
                 /*  utility functions for timeout management  */
-                const refreshPushTimeout = () => this.timerRefresh(requestId, () => {
+                const pushTimerId = `sink-push-recv:${requestId}`;
+                const refreshPushTimeout = () => this.timerRefresh(pushTimerId, () => {
                     const stream = this.pushStreams.get(requestId);
                     if (stream !== undefined)
                         stream.destroy(new Error("push stream timeout"));
                     const spool = this.pushSpools.get(requestId);
                     spool?.unroll();
                 });
-                const clearPushTimeout = () => this.timerClear(requestId);
+                const clearPushTimeout = () => this.timerClear(pushTimerId);
                 /*  create a readable for buffering received chunks  */
                 const readable = new Readable({
                     highWaterMark: chunkCredit > 0 ? chunkCredit * this.options.chunkSize : 16 * 1024,
@@ -246,11 +249,12 @@ export class SinkTrait extends SourceTrait {
         const abortController = new AbortController();
         const abortSignal = abortController.signal;
         /*  utility function for timeout refresh  */
-        const refreshTimeout = () => this.timerRefresh(requestId, () => {
+        const pushTimerId = `sink-push-send:${requestId}`;
+        const refreshTimeout = () => this.timerRefresh(pushTimerId, () => {
             abortController.abort(new Error(`push to sink "${name}" timed out`));
             spool.unroll();
         });
-        spool.roll(() => { this.timerClear(requestId); });
+        spool.roll(() => { this.timerClear(pushTimerId); });
         /*  start timeout handler  */
         refreshTimeout();
         /*  send request and wait for response before sending chunks  */

package/dst-stage1/mqtt-plus-source.js

@@ -97,12 +97,13 @@ export class SourceTrait extends ServiceTrait {
                 await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
             };
             /*  utility functions for timeout management  */
-            const refreshSourceTimeout = () => this.timerRefresh(requestId, () => {
+            const sourceTimerId = `source-fetch-send:${requestId}`;
+            const refreshSourceTimeout = () => this.timerRefresh(sourceTimerId, () => {
                 const gate = this.sourceCreditGates.get(requestId);
                 if (gate !== undefined)
                     gate.abort();
             });
-            const clearSourceTimeout = () => this.timerClear(requestId);
+            const clearSourceTimeout = () => this.timerClear(sourceTimerId);
             refreshSourceTimeout();
             /*  callback for creating and sending a chunk message  */
             const sendChunk = async (chunk, error, final) => {

package/dst-stage1/mqtt-plus-subscription.d.ts

@@ -10,6 +10,8 @@ declare class RefCountedSubscription {
     private lingers;
     private unsubbing;
     constructor(subscribeFn: (topic: string, options: IClientSubscribeOptions) => Promise<void>, unsubscribeFn: (topic: string) => Promise<void>, lingerMs?: number);
+    private incrementCount;
+    private decrementCount;
     subscribe(topic: string, options?: IClientSubscribeOptions): Promise<void>;
     unsubscribe(topic: string): Promise<void>;
     flush(): Promise<void>;

package/dst-stage1/mqtt-plus-subscription.js

@@ -24,20 +24,42 @@
 import { BaseTrait } from "./mqtt-plus-base";
 /*  reference-counted subscription helper  */
 class RefCountedSubscription {
+    /*  initial construction with configuration  */
     constructor(subscribeFn, unsubscribeFn, lingerMs = 30 * 1000) {
         this.subscribeFn = subscribeFn;
         this.unsubscribeFn = unsubscribeFn;
         this.lingerMs = lingerMs;
+        /*  internal state  */
         this.counts = new Map();
         this.pending = new Map();
         this.lingers = new Map();
         this.unsubbing = new Map();
     }
+    /*  increment reference count for a topic  */
+    incrementCount(topic) {
+        const count = this.counts.get(topic) ?? 0;
+        this.counts.set(topic, count + 1);
+        return count;
+    }
+    /*  decrement reference count for a topic  */
+    decrementCount(topic) {
+        const count = this.counts.get(topic);
+        if (count) {
+            if (count <= 1) {
+                this.counts.delete(topic);
+                return 0;
+            }
+            else {
+                this.counts.set(topic, count - 1);
+                return count - 1;
+            }
+        }
+        return undefined;
+    }
     /*  subscribe to a topic (reference-counted)  */
     async subscribe(topic, options = { qos: 2 }) {
         /*  increment count first to reserve our interest  */
-        const count = this.counts.get(topic) ?? 0;
-        this.counts.set(topic, count + 1);
+        const count = this.incrementCount(topic);
         /*  optionally just cancel a pending linger unsubscription
             (subscription is still kept active on the broker)  */
         const linger = this.lingers.get(topic);
@@ -48,24 +70,31 @@ class RefCountedSubscription {
         }
         /*  if we are the first, we must perform the actual subscription  */
         if (count === 0) {
+            /*  create a deferred promise and store it in pending immediately,
+                so concurrent subscribers arriving during the await below
+                will find and await it instead of returning prematurely  */
+            let resolve;
+            let reject;
+            const deferred = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            this.pending.set(topic, deferred);
             /*  await any in-flight linger unsubscription to avoid a race
                 where the broker processes UNSUBSCRIBE after our SUBSCRIBE  */
             const inflight = this.unsubbing.get(topic);
             if (inflight)
                 await inflight;
-            const promise = this.subscribeFn(topic, options).finally(() => {
+            /*  perform the actual subscription  */
+            const promise = this.subscribeFn(topic, options).then(() => {
                 this.pending.delete(topic);
+                resolve();
             }).catch((err) => {
-                const count = this.counts.get(topic);
-                if (count) {
-                    if (count <= 1)
-                        this.counts.delete(topic);
-                    else
-                        this.counts.set(topic, count - 1);
-                }
+                this.pending.delete(topic);
+                this.decrementCount(topic);
+                reject(err);
                 throw err;
             });
-            this.pending.set(topic, promise);
             return promise;
         }
         else {
@@ -73,39 +102,35 @@ class RefCountedSubscription {
             const pending = this.pending.get(topic);
             if (pending)
                 return pending.catch((err) => {
-                    const count = this.counts.get(topic);
-                    if (count) {
-                        if (count <= 1)
-                            this.counts.delete(topic);
-                        else
-                            this.counts.set(topic, count - 1);
-                    }
+                    this.decrementCount(topic);
                     throw err;
                 });
         }
     }
     /*  unsubscribe from a topic (reference-counted)  */
     async unsubscribe(topic) {
-        const count = this.counts.get(topic);
-        if (count) {
-            if (count <= 1) {
-                this.counts.delete(topic);
-                if (this.lingerMs > 0) {
-                    /*  defer the actual broker unsubscription  */
-                    const timer = setTimeout(() => {
-                        this.lingers.delete(topic);
-                        const promise = this.unsubscribeFn(topic).catch(() => { }).finally(() => {
-                            this.unsubbing.delete(topic);
-                        });
-                        this.unsubbing.set(topic, promise);
-                    }, this.lingerMs);
-                    this.lingers.set(topic, timer);
-                }
-                else
-                    await this.unsubscribeFn(topic).catch(() => { });
+        const count = this.decrementCount(topic);
+        if (count === 0) {
+            if (this.lingerMs > 0) {
+                /*  defer the actual broker unsubscription  */
+                const timer = setTimeout(() => {
+                    this.lingers.delete(topic);
+                    const promise = this.unsubscribeFn(topic).catch(() => { }).finally(() => {
+                        this.unsubbing.delete(topic);
+                    });
+                    this.unsubbing.set(topic, promise);
+                }, this.lingerMs);
+                this.lingers.set(topic, timer);
+            }
+            else {
+                /*  perform the unsubscription immediately, but still store the
+                    promise in unsubbing so a concurrent subscribe can await it  */
+                const promise = this.unsubscribeFn(topic).catch(() => { }).finally(() => {
+                    this.unsubbing.delete(topic);
+                });
+                this.unsubbing.set(topic, promise);
+                await promise;
             }
-            else
-                this.counts.set(topic, count - 1);
         }
     }
     /*  flush all pending linger timers and unsubscribe  */

package/dst-stage1/mqtt-plus-trace.js

@@ -38,9 +38,9 @@ class LogEvent {
         if (this.msg instanceof Promise)
             this.msg = await this.msg.catch(() => "<resolve-failed>");
         if (this.data)
-            for (const field of Object.keys(this.data))
-                if (this.data[field] instanceof Promise)
-                    this.data[field] = await this.data[field].catch(() => "<resolve-failed>");
+            for (const k of Object.keys(this.data))
+                if (this.data[k] instanceof Promise)
+                    this.data[k] = await this.data[k].catch(() => "<resolve-failed>");
     }
     /*  render log event as string  */
     toString() {

package/dst-stage1/mqtt-plus-util.js

@@ -85,9 +85,9 @@ function uint8ArrayConcat(arrays) {
     const totalLength = arrays.reduce((acc, value) => acc + value.byteLength, 0);
     const result = new Uint8Array(totalLength);
     let offset = 0;
-    for (const array of arrays) {
-        result.set(array, offset);
-        offset += array.byteLength;
+    for (const a of arrays) {
+        result.set(a, offset);
+        offset += a.byteLength;
     }
     return result;
 }