mqtt-plus 0.9.12 → 0.9.14

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

@@ -2,9 +2,11 @@ import { APISchema } from "./mqtt-plus-api";
 import { APIOptions, OptionsTrait } from "./mqtt-plus-options";
 export default class Codec {
     private type;
+    private types;
+    private tags;
     constructor(type: "cbor" | "json");
-    encode(data: unknown): Buffer | string;
-    decode(data: Buffer | string): unknown;
+    encode(data: unknown): Uint8Array | string;
+    decode(data: Uint8Array | string): unknown;
 }
 export declare class CodecTrait<T extends APISchema = APISchema> extends OptionsTrait<T> {
     protected codec: Codec;

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

@@ -22,18 +22,51 @@
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 /*  external requirements  */
-import CBOR from "cbor";
+import * as CBOR from "cbor2";
 import { OptionsTrait } from "./mqtt-plus-options";
+/*  JSON encode/decode with Uint8Array support  */
+class JSONX {
+    static uint8ArrayToBase64(arr) {
+        return btoa(String.fromCharCode(...arr));
+    }
+    static base64ToUint8Array(base64) {
+        const binary = atob(base64);
+        const arr = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            arr[i] = binary.charCodeAt(i);
+        return arr;
+    }
+    static stringify(obj) {
+        return JSON.stringify(obj, (_, value) => value instanceof Uint8Array
+            ? { __Uint8Array: this.uint8ArrayToBase64(value) }
+            : value);
+    }
+    static parse(json) {
+        return JSON.parse(json, (_, value) => value?.__Uint8Array
+            ? this.base64ToUint8Array(value.__Uint8Array)
+            : value);
+    }
+}
 /*  the encoder/decoder abstraction  */
 export default class Codec {
     constructor(type) {
         this.type = type;
+        this.types = new CBOR.TypeEncoderMap();
+        this.tags = new Map();
+        /*  support direct encoding/decoding of Buffer  */
+        const TAG_BUFFER = 64000;
+        this.types.registerEncoder(Buffer, (buffer) => {
+            return [TAG_BUFFER, new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)];
+        });
+        this.tags.set(TAG_BUFFER, (tag) => {
+            return Buffer.from(tag.contents);
+        });
     }
     encode(data) {
         let result;
         if (this.type === "cbor") {
             try {
-                result = CBOR.encode(data);
+                result = CBOR.encode(data, { types: this.types });
             }
             catch (_ex) {
                 throw new Error("failed to encode CBOR format");
@@ -41,7 +74,7 @@ export default class Codec {
         }
         else if (this.type === "json") {
             try {
-                result = JSON.stringify(data);
+                result = JSONX.stringify(data);
             }
             catch (_ex) {
                 throw new Error("failed to encode JSON format");
@@ -53,9 +86,11 @@ export default class Codec {
     }
     decode(data) {
         let result;
-        if (this.type === "cbor" && typeof data === "object" && data instanceof Buffer) {
+        if (this.type === "cbor"
+            && typeof data === "object"
+            && data instanceof Uint8Array) {
             try {
-                result = CBOR.decode(data);
+                result = CBOR.decode(data, { tags: this.tags });
             }
             catch (_ex) {
                 throw new Error("failed to decode CBOR format");
@@ -63,7 +98,7 @@ export default class Codec {
         }
         else if (this.type === "json" && typeof data === "string") {
             try {
-                result = JSON.parse(data);
+                result = JSONX.parse(data);
             }
             catch (_ex) {
                 throw new Error("failed to decode JSON format");

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

@@ -21,6 +21,8 @@
 **  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
+/*  built-in requirements  */
+import { Buffer } from "node:buffer";
 import { nanoid } from "nanoid";
 /*  internal requirements  */
 import { EventEmission } from "./mqtt-plus-msg";
@@ -98,7 +100,7 @@ export class EventTrait extends BaseTrait {
         /*  generate corresponding MQTT topic  */
         const topic = this.options.topicMake(event, "event-emission", receiver);
         /*  publish message to MQTT topic  */
-        this.mqtt.publish(topic, message, { qos: 0, ...options });
+        this.mqtt.publish(topic, Buffer.from(message), { qos: 0, ...options });
     }
     /*  dispatch message (Event pattern handling)  */
     _dispatchMessage(topic, parsed) {
@@ -111,7 +113,9 @@ export class EventTrait extends BaseTrait {
             const name = parsed.event;
             const handler = this.subscriptions.get(name);
             const params = parsed.params ?? [];
-            const info = { sender: parsed.sender ?? "", receiver: parsed.receiver };
+            const info = { sender: parsed.sender ?? "" };
+            if (parsed.receiver)
+                info.receiver = parsed.receiver;
             Promise.resolve()
                 .then(() => handler?.(...params, info))
                 .catch((err) => {

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

@@ -1,4 +1,4 @@
-import { Readable } from "stream";
+import { Readable } from "node:stream";
 export interface InfoBase {
     sender: string;
     receiver?: string;
@@ -10,6 +10,6 @@ export interface InfoService extends InfoBase {
 export interface InfoResource extends InfoBase {
     meta?: Record<string, any>;
     stream?: Readable;
-    buffer?: Promise<Buffer>;
+    buffer?: Promise<Uint8Array>;
 }
 export type WithInfo<F, I extends InfoBase> = F extends (...args: infer P) => infer R ? (...args: [...P, info: I]) => R : never;

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

@@ -30,18 +30,18 @@ export declare class ResourceTransferRequest extends Base {
 export declare class ResourceTransferResponse extends Base {
     resource?: string | undefined;
     params?: any[] | undefined;
-    chunk?: Buffer | undefined;
+    chunk?: Uint8Array | undefined;
     meta?: Record<string, any> | undefined;
     error?: string | undefined;
     final?: boolean | undefined;
-    constructor(id: string, resource?: string | undefined, params?: any[] | undefined, chunk?: Buffer | undefined, meta?: Record<string, any> | undefined, error?: string | undefined, final?: boolean | undefined, sender?: string, receiver?: string);
+    constructor(id: string, resource?: string | undefined, params?: any[] | undefined, chunk?: Uint8Array | undefined, meta?: Record<string, any> | undefined, error?: string | undefined, final?: boolean | undefined, sender?: string, receiver?: string);
 }
 declare class Msg {
     makeEventEmission(id: string, event: string, params?: any[], sender?: string, receiver?: string): EventEmission;
     makeServiceCallRequest(id: string, service: string, params?: any[], sender?: string, receiver?: string): ServiceCallRequest;
     makeServiceCallResponse(id: string, result?: any, error?: string, sender?: string, receiver?: string): ServiceCallResponse;
     makeResourceTransferRequest(id: string, resource: string, params?: any[], sender?: string, receiver?: string): ResourceTransferRequest;
-    makeResourceTransferResponse(id: string, resource?: string, params?: any[], chunk?: Buffer, meta?: Record<string, any>, error?: string, final?: boolean, sender?: string, receiver?: string): ResourceTransferResponse;
+    makeResourceTransferResponse(id: string, resource?: string, params?: any[], chunk?: Uint8Array, meta?: Record<string, any>, error?: string, final?: boolean, sender?: string, receiver?: string): ResourceTransferResponse;
     parse(obj: any): EventEmission | ServiceCallRequest | ServiceCallResponse | ResourceTransferRequest | ResourceTransferResponse;
 }
 export declare class MsgTrait<T extends APISchema = APISchema> extends CodecTrait<T> {

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

@@ -1,4 +1,4 @@
-import { Readable } from "stream";
+import { Readable } from "node:stream";
 import { IClientPublishOptions, IClientSubscribeOptions } from "mqtt";
 import { APISchema, ResourceKeys } from "./mqtt-plus-api";
 import type { WithInfo, InfoResource } from "./mqtt-plus-info";
@@ -13,10 +13,10 @@ export declare class ResourceTrait<T extends APISchema = APISchema> extends Serv
     private pushTimers;
     provision<K extends ResourceKeys<T> & string>(resource: K, callback: WithInfo<T[K], InfoResource>): Promise<Provisioning>;
     provision<K extends ResourceKeys<T> & string>(resource: K, options: Partial<IClientSubscribeOptions>, callback: WithInfo<T[K], InfoResource>): Promise<Provisioning>;
-    push<K extends ResourceKeys<T> & string>(resource: K, data: Readable | Buffer, ...params: Parameters<T[K]>): Promise<void>;
+    push<K extends ResourceKeys<T> & string>(resource: K, data: Readable | Uint8Array, ...params: Parameters<T[K]>): Promise<void>;
     push<K extends ResourceKeys<T> & string>(config: {
         resource: K;
-        data: Readable | Buffer;
+        data: Readable | Uint8Array;
         params: Parameters<T[K]>;
         meta?: Record<string, any>;
         receiver?: string;
@@ -24,7 +24,7 @@ export declare class ResourceTrait<T extends APISchema = APISchema> extends Serv
     }): Promise<void>;
     fetch<K extends ResourceKeys<T> & string>(resource: K, ...params: Parameters<T[K]>): Promise<{
         stream: Readable;
-        buffer: Promise<Buffer>;
+        buffer: Promise<Uint8Array>;
         meta: Promise<Record<string, any> | undefined>;
     }>;
     fetch<K extends ResourceKeys<T> & string>(config: {
@@ -34,7 +34,7 @@ export declare class ResourceTrait<T extends APISchema = APISchema> extends Serv
         options?: IClientPublishOptions;
     }): Promise<{
         stream: Readable;
-        buffer: Promise<Buffer>;
+        buffer: Promise<Uint8Array>;
         meta: Promise<Record<string, any> | undefined>;
     }>;
     protected _dispatchMessage(topic: string, parsed: any): void;

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

@@ -22,7 +22,8 @@
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 /*  built-in requirements  */
-import { Readable } from "stream";
+import { Buffer } from "node:buffer";
+import { Readable } from "node:stream";
 import { nanoid } from "nanoid";
 /*  internal requirements  */
 import { streamToBuffer, sendBufferAsChunks, sendStreamAsChunks } from "./mqtt-plus-util";
@@ -121,7 +122,7 @@ export class ResourceTrait extends ServiceTrait {
             firstChunk = false;
             const request = this.msg.makeResourceTransferResponse(rid, resource, params, chunk, chunkMeta, error, final, this.options.id, receiver);
             const message = this.codec.encode(request);
-            this.mqtt.publish(topic, message, { qos: 2, ...options });
+            this.mqtt.publish(topic, Buffer.from(message), { qos: 2, ...options });
         };
         /*  iterate over all chunks of the buffer  */
         return new Promise((resolve, reject) => {
@@ -129,7 +130,7 @@ export class ResourceTrait extends ServiceTrait {
                 /*  attach to the readable  */
                 sendStreamAsChunks(streamOrBuffer, this.options.chunkSize, sendChunk, () => resolve(), (err) => reject(err));
             }
-            else if (streamOrBuffer instanceof Buffer) {
+            else if (streamOrBuffer instanceof Uint8Array) {
                 /*  split buffer into chunks and send them  */
                 sendBufferAsChunks(streamOrBuffer, this.options.chunkSize, sendChunk);
                 resolve();
@@ -171,13 +172,15 @@ export class ResourceTrait extends ServiceTrait {
         /*  define timer  */
         let timer = null;
         /*  utility function for cleanup  */
-        const cleanup = () => {
+        const cleanup = (resolveMeta = false) => {
             if (timer !== null) {
                 clearTimeout(timer);
                 timer = null;
             }
             this._unsubscribeTopic(responseTopic).catch(() => { });
             this.callbacks.delete(requestId);
+            if (resolveMeta)
+                metaResolve?.(undefined);
         };
         /*  start timeout handler  */
         timer = setTimeout(() => {
@@ -195,7 +198,7 @@ export class ResourceTrait extends ServiceTrait {
                     metaResolve?.(meta);
                 }
                 if (error !== undefined) {
-                    cleanup();
+                    cleanup(true);
                     stream.destroy(error);
                 }
                 else {
@@ -214,7 +217,7 @@ export class ResourceTrait extends ServiceTrait {
         /*  generate corresponding MQTT topic  */
         const topic = this.options.topicMake(resource, "resource-transfer-request", receiver);
         /*  publish message to MQTT topic  */
-        this.mqtt.publish(topic, message, { qos: 2, ...options });
+        this.mqtt.publish(topic, Buffer.from(message), { qos: 2, ...options });
         /*  produce result  */
         return { stream, buffer, meta };
     }
@@ -235,7 +238,9 @@ export class ResourceTrait extends ServiceTrait {
                 const params = parsed.params ?? [];
                 const sender = parsed.sender ?? "";
                 const receiver = parsed.receiver;
-                const info = { sender, receiver };
+                const info = { sender };
+                if (receiver)
+                    info.receiver = receiver;
                 /*  generate corresponding MQTT topic  */
                 const responseTopic = this.options.topicMake(resource, "resource-transfer-response", sender);
                 /*  callback for creating and sending a chunk message  */
@@ -244,7 +249,7 @@ export class ResourceTrait extends ServiceTrait {
                     const chunkMeta = firstChunk ? info.meta : undefined;
                     firstChunk = false;
                     const request = this.msg.makeResourceTransferResponse(requestId, resource, undefined, chunk, chunkMeta, error, final, this.options.id, sender);
-                    const message = this.codec.encode(request);
+                    const message = Buffer.from(this.codec.encode(request));
                     this.mqtt.publish(responseTopic, message, { qos: 2 });
                 };
                 /*  call the handler callback  */
@@ -276,8 +281,8 @@ export class ResourceTrait extends ServiceTrait {
             const error = parsed.error;
             const meta = parsed.meta;
             const final = parsed.final;
-            const chunk = (parsed.chunk !== undefined && !Buffer.isBuffer(parsed.chunk))
-                ? Buffer.from(parsed.chunk) : parsed.chunk;
+            const chunk = (parsed.chunk !== undefined && !(parsed.chunk instanceof Uint8Array))
+                ? Uint8Array.from(parsed.chunk) : parsed.chunk;
             /*  case 1: response on fetch  */
             const handler = this.callbacks.get(requestId);
             if (handler !== undefined)
@@ -304,13 +309,13 @@ export class ResourceTrait extends ServiceTrait {
                         /*  prepare info object  */
                         const promise = streamToBuffer(readable);
                         const params = parsed.params ?? [];
-                        const info = {
-                            sender: parsed.sender ?? "",
-                            receiver: parsed.receiver,
-                            meta: meta,
-                            stream: readable,
-                            buffer: promise
-                        };
+                        const info = { sender: parsed.sender ?? "" };
+                        if (parsed.receiver)
+                            info.receiver = parsed.receiver;
+                        if (parsed.meta)
+                            info.meta = meta;
+                        info.stream = readable;
+                        info.buffer = promise;
                         /*  call handler  */
                         Promise.resolve()
                             .then(() => handler(...params, info))

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

@@ -21,6 +21,8 @@
 **  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 **  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
+/*  built-in requirements  */
+import { Buffer } from "node:buffer";
 import { nanoid } from "nanoid";
 /*  internal requirements  */
 import { ServiceCallRequest, ServiceCallResponse } from "./mqtt-plus-msg";
@@ -124,7 +126,7 @@ export class ServiceTrait extends EventTrait {
         /*  generate corresponding MQTT topic  */
         const topic = this.options.topicMake(service, "service-call-request", receiver);
         /*  publish message to MQTT topic  */
-        this.mqtt.publish(topic, message, { qos: 2, ...options }, (err) => {
+        this.mqtt.publish(topic, Buffer.from(message), { qos: 2, ...options }, (err) => {
             /*  handle request failure (only if not already handled)  */
             if (err) {
                 const pendingRequest = this.responseCallback.get(rid);
@@ -185,7 +187,9 @@ export class ServiceTrait extends EventTrait {
             if (handler !== undefined) {
                 /*  execute service handler  */
                 const params = parsed.params ?? [];
-                const info = { sender: parsed.sender ?? "", receiver: parsed.receiver };
+                const info = { sender: parsed.sender ?? "" };
+                if (parsed.receiver)
+                    info.receiver = parsed.receiver;
                 response = Promise.resolve().then(() => handler(...params, info));
             }
             else
@@ -212,7 +216,7 @@ export class ServiceTrait extends EventTrait {
                     throw new Error("invalid request: missing sender");
                 const encoded = this.codec.encode(rpcResponse);
                 const topic = this.options.topicMake(name, "service-call-response", senderPeerId);
-                this.mqtt.publish(topic, encoded, { qos: 2 });
+                this.mqtt.publish(topic, Buffer.from(encoded), { qos: 2 });
             }).catch((err) => {
                 this.mqtt.emit("error", err);
             });

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

@@ -1,5 +1,5 @@
-import { Readable } from "stream";
-export declare function streamToBuffer(stream: Readable): Promise<Buffer>;
-export type SendChunkCallback = (chunk: Buffer | undefined, error: string | undefined, final: boolean) => void;
-export declare function sendBufferAsChunks(buffer: Buffer, chunkSize: number, sendChunk: SendChunkCallback): void;
+import { Readable } from "node:stream";
+export declare function streamToBuffer(stream: Readable): Promise<Uint8Array>;
+export type SendChunkCallback = (chunk: Uint8Array | undefined, error: string | undefined, final: boolean) => void;
+export declare function sendBufferAsChunks(buffer: Uint8Array, chunkSize: number, sendChunk: SendChunkCallback): void;
 export declare function sendStreamAsChunks(readable: Readable, chunkSize: number, sendChunk: SendChunkCallback, onEnd: () => void, onError: (err: Error) => void): void;

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

@@ -23,35 +23,47 @@
 */
 /*  external requirements  */
 import PLazy from "p-lazy";
-/*  utility function for collecting stream chunks into a Buffer  */
+/*  concatenate elements of an Uint8Array array  */
+function uint8ArrayConcat(arrays) {
+    const totalLength = arrays.reduce((acc, value) => acc + value.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+/*  utility function for collecting stream chunks into a buffer  */
 export function streamToBuffer(stream) {
     return new PLazy((resolve, reject) => {
         const chunks = [];
-        stream.on("data", (data) => {
+        stream.on("data", (_data) => {
+            const data = chunkToBuffer(_data);
             chunks.push(data);
         });
         stream.on("end", () => {
-            resolve(Buffer.concat(chunks));
+            resolve(uint8ArrayConcat(chunks));
         });
         stream.on("error", (err) => {
             reject(err);
         });
     });
 }
-/*  utility function for converting a chunk to a Buffer  */
+/*  utility function for converting a chunk to a buffer  */
 function chunkToBuffer(chunk) {
     let buffer;
-    if (Buffer.isBuffer(chunk))
+    if (chunk instanceof Buffer)
+        buffer = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.length);
+    else if (chunk instanceof Uint8Array)
         buffer = chunk;
     else if (typeof chunk === "string")
-        buffer = Buffer.from(chunk);
-    else if (chunk instanceof Uint8Array)
-        buffer = Buffer.from(chunk);
+        buffer = new TextEncoder().encode(chunk);
     else
-        buffer = Buffer.from(String(chunk));
+        buffer = new TextEncoder().encode(String(chunk));
     return buffer;
 }
-/*  utility function for sending a Buffer as chunks  */
+/*  utility function for sending a buffer as chunks  */
 export function sendBufferAsChunks(buffer, chunkSize, sendChunk) {
     if (buffer.byteLength === 0) {
         /*  handle empty buffer by sending final chunk  */