mqtt-plus 0.9.0

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

@@ -0,0 +1,128 @@
+/*
+**  MQTT+ -- MQTT Communication Patterns
+**  Copyright (c) 2018-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**
+**  Permission is hereby granted, free of charge, to any person obtaining
+**  a copy of this software and associated documentation files (the
+**  "Software"), to deal in the Software without restriction, including
+**  without limitation the rights to use, copy, modify, merge, publish,
+**  distribute, sublicense, and/or sell copies of the Software, and to
+**  permit persons to whom the Software is furnished to do so, subject to
+**  the following conditions:
+**
+**  The above copyright notice and this permission notice shall be included
+**  in all copies or substantial portions of the Software.
+**
+**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+**  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+**  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+**  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+**  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+**  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+**  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+/*  base class  */
+export class Base {
+    constructor(id, sender, receiver) {
+        this.id = id;
+        this.sender = sender;
+        this.receiver = receiver;
+    }
+}
+/*  event emission  */
+export class EventEmission extends Base {
+    constructor(id, event, params, sender, receiver) {
+        super(id, sender, receiver);
+        this.event = event;
+        this.params = params;
+    }
+}
+/*  service request  */
+export class ServiceRequest extends Base {
+    constructor(id, service, params, sender, receiver) {
+        super(id, sender, receiver);
+        this.service = service;
+        this.params = params;
+    }
+}
+/*  service response success  */
+export class ServiceResponseSuccess extends Base {
+    constructor(id, result, sender, receiver) {
+        super(id, sender, receiver);
+        this.result = result;
+    }
+}
+/*  service response error  */
+export class ServiceResponseError extends Base {
+    constructor(id, error, sender, receiver) {
+        super(id, sender, receiver);
+        this.error = error;
+    }
+}
+/*  utility class  */
+export default class Msg {
+    /*  factory for event emission  */
+    makeEventEmission(id, event, params, sender, receiver) {
+        return new EventEmission(id, event, params, sender, receiver);
+    }
+    /*  factory for service request  */
+    makeServiceRequest(id, service, params, sender, receiver) {
+        return new ServiceRequest(id, service, params, sender, receiver);
+    }
+    /*  factory for service response success  */
+    makeServiceResponseSuccess(id, result, sender, receiver) {
+        return new ServiceResponseSuccess(id, result, sender, receiver);
+    }
+    /*  factory for service response error  */
+    makeServiceResponseError(id, error, sender, receiver) {
+        return new ServiceResponseError(id, error, sender, receiver);
+    }
+    /*  parse any object into typed object  */
+    parse(obj) {
+        if (typeof obj !== "object" || obj === null)
+            throw new Error("invalid argument: not an object");
+        /*  validate common fields  */
+        if (!("id" in obj) || typeof obj.id !== "string")
+            throw new Error("invalid object: missing or invalid \"id\" field");
+        if ("sender" in obj && typeof obj.sender !== "string")
+            throw new Error("invalid object: invalid \"sender\" field");
+        if ("receiver" in obj && typeof obj.sender !== "string")
+            throw new Error("invalid object: invalid \"receiver\" field");
+        /*  dispatch according to type indication by field  */
+        const anyFieldsExcept = (obj, allowed) => Object.keys(obj).some((key) => !allowed.includes(key));
+        if ("event" in obj) {
+            /*  detect and parse event emission  */
+            if (typeof obj.event !== "string")
+                throw new Error("invalid EventEmission object: \"event\" field must be a string");
+            if (anyFieldsExcept(obj, ["type", "id", "event", "params", "sender", "receiver"]))
+                throw new Error("invalid EventEmission object: contains unknown fields");
+            if (obj.params !== undefined && (typeof obj.params !== "object" || !Array.isArray(obj.params)))
+                throw new Error("invalid EventEmission object: \"params\" field must be an array");
+            return this.makeEventEmission(obj.id, obj.event, obj.params, obj.sender, obj.receiver);
+        }
+        else if ("service" in obj) {
+            /*  detect and parse service request  */
+            if (typeof obj.service !== "string")
+                throw new Error("invalid ServiceRequest object: \"service\" field must be a string");
+            if (anyFieldsExcept(obj, ["type", "id", "service", "params", "sender", "receiver"]))
+                throw new Error("invalid ServiceRequest object: contains unknown fields");
+            if (obj.params !== undefined && (typeof obj.params !== "object" || !Array.isArray(obj.params)))
+                throw new Error("invalid ServiceRequest object: \"params\" field must be an array");
+            return this.makeServiceRequest(obj.id, obj.service, obj.params, obj.sender, obj.receiver);
+        }
+        else if ("result" in obj) {
+            /*  detect and parse service response success  */
+            if (anyFieldsExcept(obj, ["type", "id", "result", "sender", "receiver"]))
+                throw new Error("invalid ServiceResponseSuccess object: contains unknown fields");
+            return this.makeServiceResponseSuccess(obj.id, obj.result, obj.sender, obj.receiver);
+        }
+        else if ("error" in obj) {
+            /*  detect and parse service response error  */
+            if (anyFieldsExcept(obj, ["type", "id", "error", "sender", "receiver"]))
+                throw new Error("invalid ServiceResponseError object: contains unknown fields");
+            return this.makeServiceResponseError(obj.id, obj.error, obj.sender, obj.receiver);
+        }
+        else
+            throw new Error("invalid object: not of any known type");
+    }
+}

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

@@ -0,0 +1,73 @@
+import { MqttClient, IClientPublishOptions, IClientSubscribeOptions } from "mqtt";
+export type Receiver = {
+    __receiver: string;
+};
+export type TopicMake = (name: string, peerId?: string) => string;
+export type TopicMatch = (topic: string) => TopicMatching | null;
+export type TopicMatching = {
+    name: string;
+    peerId?: string;
+};
+export interface APIOptions {
+    id: string;
+    codec: "cbor" | "json";
+    timeout: number;
+    topicEventNoticeMake: TopicMake;
+    topicServiceRequestMake: TopicMake;
+    topicServiceResponseMake: TopicMake;
+    topicEventNoticeMatch: TopicMatch;
+    topicServiceRequestMatch: TopicMatch;
+    topicServiceResponseMatch: TopicMatch;
+}
+export interface Registration {
+    unregister(): Promise<void>;
+}
+export interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+export interface Info {
+    sender: string;
+    receiver?: string;
+}
+export type WithInfo<F> = F extends (...args: infer P) => infer R ? (...args: [...P, info: Info]) => R : never;
+export type APISchema = Record<string, (...args: any[]) => any>;
+export type EventKeys<T> = string extends keyof T ? string : {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R ? [R] extends [void] ? K : never : never;
+}[keyof T];
+export type ServiceKeys<T> = string extends keyof T ? string : {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R ? [R] extends [void] ? never : K : never;
+}[keyof T];
+export default class MQTTp<T extends APISchema = APISchema> {
+    private mqtt;
+    private options;
+    private codec;
+    private msg;
+    private registry;
+    private requests;
+    private subscriptions;
+    constructor(mqtt: MqttClient, options?: Partial<APIOptions>);
+    private _subscribeTopic;
+    private _unsubscribeTopic;
+    subscribe<K extends EventKeys<T> & string>(event: K, callback: WithInfo<T[K]>): Promise<Subscription>;
+    subscribe<K extends EventKeys<T> & string>(event: K, options: Partial<IClientSubscribeOptions>, callback: WithInfo<T[K]>): Promise<Subscription>;
+    register<K extends ServiceKeys<T> & string>(service: K, callback: WithInfo<T[K]>): Promise<Registration>;
+    register<K extends ServiceKeys<T> & string>(service: K, options: Partial<IClientSubscribeOptions>, callback: WithInfo<T[K]>): Promise<Registration>;
+    private _isIClientPublishOptions;
+    receiver(id: string): {
+        __receiver: string;
+    };
+    private _getReceiver;
+    private _isReceiver;
+    private _parseCallArgs;
+    emit<K extends EventKeys<T> & string>(event: K, ...params: Parameters<T[K]>): void;
+    emit<K extends EventKeys<T> & string>(event: K, receiver: Receiver, ...params: Parameters<T[K]>): void;
+    emit<K extends EventKeys<T> & string>(event: K, options: IClientPublishOptions, ...params: Parameters<T[K]>): void;
+    emit<K extends EventKeys<T> & string>(event: K, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): void;
+    call<K extends ServiceKeys<T> & string>(service: K, ...params: Parameters<T[K]>): Promise<Awaited<ReturnType<T[K]>>>;
+    call<K extends ServiceKeys<T> & string>(service: K, receiver: Receiver, ...params: Parameters<T[K]>): Promise<Awaited<ReturnType<T[K]>>>;
+    call<K extends ServiceKeys<T> & string>(service: K, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<Awaited<ReturnType<T[K]>>>;
+    call<K extends ServiceKeys<T> & string>(service: K, receiver: Receiver, options: IClientPublishOptions, ...params: Parameters<T[K]>): Promise<Awaited<ReturnType<T[K]>>>;
+    private _responseSubscribe;
+    private _responseUnsubscribe;
+    private _onMessage;
+}

package/dst-stage1/mqtt-plus.js

@@ -0,0 +1,408 @@
+/*
+**  MQTT+ -- MQTT Communication Patterns
+**  Copyright (c) 2018-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**
+**  Permission is hereby granted, free of charge, to any person obtaining
+**  a copy of this software and associated documentation files (the
+**  "Software"), to deal in the Software without restriction, including
+**  without limitation the rights to use, copy, modify, merge, publish,
+**  distribute, sublicense, and/or sell copies of the Software, and to
+**  permit persons to whom the Software is furnished to do so, subject to
+**  the following conditions:
+**
+**  The above copyright notice and this permission notice shall be included
+**  in all copies or substantial portions of the Software.
+**
+**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+**  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+**  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+**  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+**  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+**  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+**  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+import { nanoid } from "nanoid";
+/*  internal requirements  */
+import Codec from "./mqtt-plus-codec";
+import Msg, { EventEmission, ServiceRequest, ServiceResponseSuccess, ServiceResponseError } from "./mqtt-plus-msg";
+/*  MQTTp API class  */
+export default class MQTTp {
+    /*  construct API class  */
+    constructor(mqtt, options = {}) {
+        this.mqtt = mqtt;
+        this.msg = new Msg();
+        this.registry = new Map();
+        this.requests = new Map();
+        this.subscriptions = new Map();
+        /*  determine options and provide defaults  */
+        this.options = {
+            id: nanoid(),
+            codec: "cbor",
+            timeout: 10 * 1000,
+            topicEventNoticeMake: (name, peerId) => {
+                return peerId
+                    ? `${name}/event-notice/${peerId}`
+                    : `${name}/event-notice`;
+            },
+            topicServiceRequestMake: (name, peerId) => {
+                return peerId
+                    ? `${name}/service-request/${peerId}`
+                    : `${name}/service-request`;
+            },
+            topicServiceResponseMake: (name, peerId) => {
+                return peerId
+                    ? `${name}/service-response/${peerId}`
+                    : `${name}/service-response`;
+            },
+            topicEventNoticeMatch: (topic) => {
+                const m = topic.match(/^(.+?)\/event-notice(?:\/(.+))?$/);
+                return m ? { name: m[1], peerId: m[2] } : null;
+            },
+            topicServiceRequestMatch: (topic) => {
+                const m = topic.match(/^(.+?)\/service-request(?:\/(.+))?$/);
+                return m ? { name: m[1], peerId: m[2] } : null;
+            },
+            topicServiceResponseMatch: (topic) => {
+                const m = topic.match(/^(.+?)\/service-response\/(.+)$/);
+                return m ? { name: m[1], peerId: m[2] } : null;
+            },
+            ...options
+        };
+        /*  establish an encoder  */
+        this.codec = new Codec(this.options.codec);
+        /*  hook into the MQTT message processing  */
+        this.mqtt.on("message", (topic, message) => {
+            this._onMessage(topic, message);
+        });
+    }
+    /*  subscribe to an MQTT topic (Promise-based)  */
+    async _subscribeTopic(topic, options = {}) {
+        return new Promise((resolve, reject) => {
+            this.mqtt.subscribe(topic, { qos: 2, ...options }, (err, _granted) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    /*  unsubscribe from an MQTT topic (Promise-based)  */
+    async _unsubscribeTopic(topic) {
+        return new Promise((resolve, reject) => {
+            this.mqtt.unsubscribe(topic, (err, _packet) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    async subscribe(event, ...args) {
+        /*  determine parameters  */
+        let options = {};
+        let callback = args[0];
+        if (args.length === 2 && typeof args[0] === "object") {
+            options = args[0];
+            callback = args[1];
+        }
+        /*  sanity check situation  */
+        if (this.registry.has(event))
+            throw new Error(`subscribe: event "${event}" already subscribed`);
+        /*  generate the corresponding MQTT topics for broadcast and direct use  */
+        const topicB = this.options.topicEventNoticeMake(event);
+        const topicD = this.options.topicEventNoticeMake(event, this.options.id);
+        /*  subscribe to MQTT topics  */
+        await Promise.all([
+            this._subscribeTopic(topicB, { qos: 0, ...options }),
+            this._subscribeTopic(topicD, { qos: 0, ...options })
+        ]).catch((err) => {
+            this._unsubscribeTopic(topicB).catch(() => { });
+            this._unsubscribeTopic(topicD).catch(() => { });
+            throw err;
+        });
+        /*  remember the subscription  */
+        this.registry.set(event, callback);
+        /*  provide a subscription for subsequent unsubscribing  */
+        const self = this;
+        const subscription = {
+            async unsubscribe() {
+                if (!self.registry.has(event))
+                    throw new Error(`unsubscribe: event "${event}" not subscribed`);
+                self.registry.delete(event);
+                return Promise.all([
+                    self._unsubscribeTopic(topicB),
+                    self._unsubscribeTopic(topicD)
+                ]).then(() => { });
+            }
+        };
+        return subscription;
+    }
+    async register(service, ...args) {
+        /*  determine parameters  */
+        let options = {};
+        let callback = args[0];
+        if (args.length === 2 && typeof args[0] === "object") {
+            options = args[0];
+            callback = args[1];
+        }
+        /*  sanity check situation  */
+        if (this.registry.has(service))
+            throw new Error(`register: service "${service}" already registered`);
+        /*  generate the corresponding MQTT topics for broadcast and direct use  */
+        const topicB = this.options.topicServiceRequestMake(service);
+        const topicD = this.options.topicServiceRequestMake(service, this.options.id);
+        /*  subscribe to MQTT topics  */
+        await Promise.all([
+            this._subscribeTopic(topicB, { qos: 2, ...options }),
+            this._subscribeTopic(topicD, { qos: 2, ...options })
+        ]).catch((err) => {
+            this._unsubscribeTopic(topicB).catch(() => { });
+            this._unsubscribeTopic(topicD).catch(() => { });
+            throw err;
+        });
+        /*  remember the registration  */
+        this.registry.set(service, callback);
+        /*  provide a registration for subsequent unregistering  */
+        const self = this;
+        const registration = {
+            async unregister() {
+                if (!self.registry.has(service))
+                    throw new Error(`unregister: service "${service}" not registered`);
+                self.registry.delete(service);
+                return Promise.all([
+                    self._unsubscribeTopic(topicB),
+                    self._unsubscribeTopic(topicD)
+                ]).then(() => { });
+            }
+        };
+        return registration;
+    }
+    /*  check whether argument has structure of interface IClientPublishOptions  */
+    _isIClientPublishOptions(arg) {
+        if (typeof arg !== "object")
+            return false;
+        const keys = ["qos", "retain", "dup", "properties", "cbStorePut"];
+        return Object.keys(arg).every((key) => keys.includes(key));
+    }
+    /*  wrap receiver id into object (required for type-safe overloading)  */
+    receiver(id) {
+        return { __receiver: id };
+    }
+    /*  return client id from wrapper object  */
+    _getReceiver(obj) {
+        return obj.__receiver;
+    }
+    /*  detect client id wrapper object  */
+    _isReceiver(obj) {
+        return (typeof obj === "object"
+            && obj !== null
+            && "__receiver" in obj
+            && typeof obj.__receiver === "string");
+    }
+    /*  parse optional peerId and options from variadic arguments  */
+    _parseCallArgs(args) {
+        let receiver;
+        let options = {};
+        let params = args;
+        if (args.length >= 2 && this._isReceiver(args[0]) && this._isIClientPublishOptions(args[1])) {
+            receiver = this._getReceiver(args[0]);
+            options = args[1];
+            params = args.slice(2);
+        }
+        else if (args.length >= 1 && this._isReceiver(args[0])) {
+            receiver = this._getReceiver(args[0]);
+            params = args.slice(1);
+        }
+        else if (args.length >= 1 && this._isIClientPublishOptions(args[0])) {
+            options = args[0];
+            params = args.slice(1);
+        }
+        return { receiver, options, params };
+    }
+    emit(event, ...args) {
+        /*  determine actual parameters  */
+        const { receiver, options, params } = this._parseCallArgs(args);
+        /*  generate unique request id  */
+        const rid = nanoid();
+        /*  generate encoded Msg message  */
+        const request = this.msg.makeEventEmission(rid, event, params, this.options.id, receiver);
+        const message = this.codec.encode(request);
+        /*  generate corresponding MQTT topic  */
+        const topic = this.options.topicEventNoticeMake(event, receiver);
+        /*  publish message to MQTT topic  */
+        this.mqtt.publish(topic, message, { qos: 2, ...options });
+    }
+    call(service, ...args) {
+        /*  determine actual parameters  */
+        const { receiver, options, params } = this._parseCallArgs(args);
+        /*  generate unique request id  */
+        const rid = nanoid();
+        /*  subscribe to MQTT response topic  */
+        this._responseSubscribe(service, { qos: options.qos ?? 2 });
+        /*  create promise for MQTT response handling  */
+        const promise = new Promise((resolve, reject) => {
+            let timer = setTimeout(() => {
+                this.requests.delete(rid);
+                this._responseUnsubscribe(service);
+                timer = null;
+                reject(new Error("communication timeout"));
+            }, this.options.timeout);
+            this.requests.set(rid, {
+                service,
+                callback: (err, result) => {
+                    if (timer !== null) {
+                        clearTimeout(timer);
+                        timer = null;
+                    }
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(result);
+                }
+            });
+        });
+        /*  generate encoded message  */
+        const request = this.msg.makeServiceRequest(rid, service, params, this.options.id, receiver);
+        const message = this.codec.encode(request);
+        /*  generate corresponding MQTT topic  */
+        const topic = this.options.topicServiceRequestMake(service, receiver);
+        /*  publish message to MQTT topic  */
+        this.mqtt.publish(topic, message, { qos: 2, ...options }, (err) => {
+            /*  handle request failure  */
+            const pendingRequest = this.requests.get(rid);
+            if (err && pendingRequest !== undefined) {
+                this.requests.delete(rid);
+                this._responseUnsubscribe(service);
+                pendingRequest.callback(err, undefined);
+            }
+        });
+        return promise;
+    }
+    /*  subscribe to RPC response  */
+    _responseSubscribe(service, options = { qos: 2 }) {
+        /*  generate corresponding MQTT topic  */
+        const topic = this.options.topicServiceResponseMake(service, this.options.id);
+        /*  subscribe to MQTT topic and remember subscription  */
+        if (!this.subscriptions.has(topic)) {
+            this.subscriptions.set(topic, 0);
+            this.mqtt.subscribe(topic, options, (err) => {
+                if (err)
+                    this.mqtt.emit("error", err);
+            });
+        }
+        this.subscriptions.set(topic, this.subscriptions.get(topic) + 1);
+    }
+    /*  unsubscribe from RPC response  */
+    _responseUnsubscribe(service) {
+        /*  generate corresponding MQTT topic  */
+        const topic = this.options.topicServiceResponseMake(service, this.options.id);
+        /*  short-circuit processing if (no longer) subscribed  */
+        if (!this.subscriptions.has(topic))
+            return;
+        /*  unsubscribe from MQTT topic and forget subscription  */
+        this.subscriptions.set(topic, this.subscriptions.get(topic) - 1);
+        if (this.subscriptions.get(topic) === 0) {
+            this.subscriptions.delete(topic);
+            this.mqtt.unsubscribe(topic, (err) => {
+                if (err)
+                    this.mqtt.emit("error", err);
+            });
+        }
+    }
+    /*  handle incoming MQTT message  */
+    _onMessage(topic, message) {
+        /*  ensure we handle only valid messages  */
+        let eventMatch = null;
+        let requestMatch = null;
+        let responseMatch = null;
+        if ((eventMatch = this.options.topicEventNoticeMatch(topic)) === null
+            && (requestMatch = this.options.topicServiceRequestMatch(topic)) === null
+            && (responseMatch = this.options.topicServiceResponseMatch(topic)) === null)
+            return;
+        /*  ensure we really handle only messages for us  */
+        const peerId = eventMatch?.peerId ?? requestMatch?.peerId ?? responseMatch?.peerId;
+        if (peerId !== undefined && peerId !== this.options.id)
+            return;
+        /*  try to parse payload as payload  */
+        let parsed;
+        try {
+            let input = message;
+            if (this.options.codec === "json")
+                input = message.toString();
+            const payload = this.codec.decode(input);
+            parsed = this.msg.parse(payload);
+        }
+        catch (_err) {
+            const err = _err instanceof Error
+                ? new Error(`failed to parse message: ${_err.message}`)
+                : new Error("failed to parse message");
+            this.mqtt.emit("error", err);
+            return;
+        }
+        /*  dispatch according to message type  */
+        if (parsed instanceof EventEmission) {
+            /*  just deliver event  */
+            const name = parsed.event;
+            const handler = this.registry.get(name);
+            const params = parsed.params ?? [];
+            const info = { sender: parsed.sender ?? "", receiver: parsed.receiver };
+            handler?.(...params, info);
+        }
+        else if (parsed instanceof ServiceRequest) {
+            /*  deliver service request and send response  */
+            const rid = parsed.id;
+            const name = parsed.service;
+            const handler = this.registry.get(name);
+            let response;
+            if (handler !== undefined) {
+                /*  execute service handler  */
+                const params = parsed.params ?? [];
+                const info = { sender: parsed.sender ?? "", receiver: parsed.receiver };
+                response = Promise.resolve().then(() => handler(...params, info));
+            }
+            else
+                response = Promise.reject(new Error(`method not found: ${name}`));
+            response.then((result) => {
+                /*  create success response  */
+                return this.msg.makeServiceResponseSuccess(rid, result, this.options.id, parsed.sender);
+            }, (result) => {
+                /*  determine error message and build error response  */
+                let errorMessage;
+                if (result === undefined || result === null)
+                    errorMessage = "undefined error";
+                else if (typeof result === "string")
+                    errorMessage = result;
+                else if (result instanceof Error)
+                    errorMessage = result.message;
+                else
+                    errorMessage = String(result);
+                return this.msg.makeServiceResponseError(rid, errorMessage, this.options.id, parsed.sender);
+            }).then((rpcResponse) => {
+                /*  send response message  */
+                const senderPeerId = parsed.sender;
+                if (senderPeerId === undefined)
+                    throw new Error("invalid request: missing sender");
+                const encoded = this.codec.encode(rpcResponse);
+                const topic = this.options.topicServiceResponseMake(name, senderPeerId);
+                this.mqtt.publish(topic, encoded, { qos: 2 });
+            }).catch((err) => {
+                this.mqtt.emit("error", err);
+            });
+        }
+        else if (parsed instanceof ServiceResponseSuccess || parsed instanceof ServiceResponseError) {
+            /*  handle service response  */
+            const rid = parsed.id;
+            const request = this.requests.get(rid);
+            if (request !== undefined) {
+                /*  call callback function  */
+                if (parsed instanceof ServiceResponseSuccess)
+                    request.callback(undefined, parsed.result);
+                else if (parsed instanceof ServiceResponseError)
+                    request.callback(new Error(parsed.error), undefined);
+                /*  unsubscribe from response  */
+                this.requests.delete(rid);
+                this._responseUnsubscribe(request.service);
+            }
+        }
+    }
+}