abmqtt-dist 0.0.4 → 0.0.6

package/dist/mqtt.client.js

@@ -1,423 +1,473 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.MqttClient = void 0;
-const flow_1 = require('./flow');
-const mqtt_parser_1 = require('./mqtt.parser');
-const transport_1 = require('./transport');
-const packets_1 = require('./packets');
-const errors_1 = require('./errors');
-const stream_1 = require('stream');
-const mqtt_constants_1 = require('./mqtt.constants');
-const mqtt_base_client_1 = require('./mqtt.base-client');
-const mqtt_listener_1 = require('./mqtt.listener');
-const mqtt_utilities_1 = require('./mqtt.utilities');
-const debug = require('debug');
-const reconnect_strategy_1 = require('./reconnect-strategy');
+const flow_1 = require("./flow");
+const mqtt_parser_1 = require("./mqtt.parser");
+const transport_1 = require("./transport");
+const packets_1 = require("./packets");
+const errors_1 = require("./errors");
+const stream_1 = require("stream");
+const mqtt_constants_1 = require("./mqtt.constants");
+const mqtt_base_client_1 = require("./mqtt.base-client");
+const mqtt_listener_1 = require("./mqtt.listener");
+const mqtt_utilities_1 = require("./mqtt.utilities");
+const debug = require("debug");
+const reconnect_strategy_1 = require("./reconnect-strategy");
 function tryMakeError(e) {
-    if (e && e instanceof Error) {
-        return e;
-    }
-    if (typeof e === 'string') {
-        return new Error(e);
-    }
-    return new Error(`unknown error (received: ${e})`);
+  if (e && e instanceof Error) {
+    return e;
+  }
+  if (typeof e === "string") {
+    return new Error(e);
+  }
+  return new Error(`unknown error (received: ${e})`);
 }
 class MqttClient extends mqtt_base_client_1.MqttBaseClient {
-    get keepAlive() {
-        return this.connectOptions?.keepAlive ?? 0;
-    }
-    set keepAlive(value) {
-        if (this.connectOptions) {
-            this.connectOptions.keepAlive = value;
-            if (value) {
-                this.updateKeepAlive(value);
-            }
-        }
-    }
-    constructor(options) {
-        super();
-        this.mqttDebug = debug('mqtt:client');
-        this.receiveDebug = this.mqttDebug.extend('packet');
-        this.pingDebug = this.mqttDebug.extend('ping');
-        // wrapper functions
-        this.executePeriodically = (ms, cb) => setInterval(cb, ms);
-        this.stopExecuting = ref => clearInterval(ref);
-        this.executeDelayed = (ms, cb) => setTimeout(cb, ms);
-        this.flowCounter = (0, mqtt_utilities_1.createFlowCounter)();
-        this.activeFlows = [];
-        this.messageListener = new mqtt_listener_1.MqttListener();
-        if (typeof options.autoReconnect === 'boolean') {
-            this.reconnectStrategy = options.autoReconnect
-                ? new reconnect_strategy_1.MqttsReconnectStrategyDefault()
-                : new reconnect_strategy_1.MqttsReconnectStrategyDefault(0);
-        } else {
-            this.reconnectStrategy = options.autoReconnect;
-        }
-        this.transport =
-            options.transport ??
-            new transport_1.TlsTransport({
-                host: options.host,
-                port: options.port,
-                additionalOptions: {
-                    enableTrace: options.enableTrace,
-                },
-            });
-        this.createTransformer =
-            options.createTransformer ??
-            (() =>
-                new mqtt_parser_1.MqttTransformer({
-                    debug: this.mqttDebug.extend('transformer'),
-                    mapping: options.readMap ?? packets_1.DefaultPacketReadMap,
-                }));
-        this.transformer = this.createTransformer();
-        this.transformer.options.debug ??= this.mqttDebug.extend('transformer');
-        const packetLogger = this.mqttDebug.extend('write');
-        this.writer =
-            options.packetWriter ??
-            new packets_1.PacketWriter(
-                {
-                    logPacketWrite: (0, mqtt_utilities_1.createDefaultPacketLogger)(packetLogger),
-                },
-                options.writeMap,
-            );
-    }
-    async _connect(options) {
-        this.expectCreated();
-        this.mqttDebug(`Connecting using transport "${this.transport.constructor.name}"`);
-        this.connectResolver = options;
-        this.setConnecting();
-        try {
-            await this.transport.connect();
-        } catch (e) {
-            const err = tryMakeError(e);
-            this.mqttDebug(`Transport connect error ("${this.transport.constructor.name}")`, err.message);
-            const shouldReconnect = this.reconnectStrategy?.check();
-            await this.setDisconnected(err);
-            if (shouldReconnect) {
-                return;
-            } else {
-                throw e;
-            }
-        }
-        this.createPipeline();
-        return this.registerClient(await this.resolveConnectOptions());
-    }
-    async connect(options) {
-        try {
-            await this._connect(options);
-        } catch (e) {
-            const err = tryMakeError(e);
-            this.mqttDebug(`Connection error`, err);
-            this.emitError(err);
-        }
-    }
-    createPipeline() {
-        if (!this.transport.duplex) throw new errors_1.IllegalStateError('Expected transport to expose a Duplex.');
-        this.pipeline = (0, stream_1.pipeline)(
-            this.transport.duplex,
-            this.transformer,
-            async source => {
-                for await (const chunk of source) {
-                    if (!chunk.type) {
-                        throw new Error('Chunk is not a MqttPacket');
-                    }
-                    await this.handlePacket(chunk);
-                }
-                return 'Source drained';
-            } /* bad definitions */,
-            err => {
-                if (err) this.emitError(tryMakeError(err));
-                if (!this.disconnected) {
-                    (err ? this.setDisconnected(tryMakeError(err)) : this.setDisconnected('Pipeline finished')).catch(
-                        e => this.emitWarning(e),
-                    );
-                }
-            },
-        );
-    }
-    publish(message) {
-        return this.startFlow((0, flow_1.outgoingPublishFlow)(message));
-    }
-    subscribe(subscription) {
-        return this.startFlow((0, flow_1.outgoingSubscribeFlow)(subscription));
-    }
-    unsubscribe(subscription) {
-        return this.startFlow((0, flow_1.outgoingUnsubscribeFlow)(subscription));
-    }
-    async disconnect(force = false) {
-        if (!force) {
-            return this.startFlow((0, flow_1.outgoingDisconnectFlow)()).then(async () => {
-                await this.setDisconnected('Soft disconnect');
-            });
-        } else {
-            await this.setDisconnected('Forced disconnect');
+  get keepAlive() {
+    return this.connectOptions?.keepAlive ?? 0;
+  }
+  set keepAlive(value) {
+    if (this.connectOptions) {
+      this.connectOptions.keepAlive = value;
+      if (value) {
+        this.updateKeepAlive(value);
+      }
+    }
+  }
+  constructor(options) {
+    super();
+    this.mqttDebug = debug("mqtt:client");
+    this.receiveDebug = this.mqttDebug.extend("packet");
+    this.pingDebug = this.mqttDebug.extend("ping");
+    // wrapper functions
+    this.executePeriodically = (ms, cb) => setInterval(cb, ms);
+    this.stopExecuting = (ref) => clearInterval(ref);
+    this.executeDelayed = (ms, cb) => setTimeout(cb, ms);
+    this.flowCounter = (0, mqtt_utilities_1.createFlowCounter)();
+    this.activeFlows = [];
+    this.messageListener = new mqtt_listener_1.MqttListener();
+    if (typeof options.autoReconnect === "boolean") {
+      this.reconnectStrategy = options.autoReconnect
+        ? new reconnect_strategy_1.MqttsReconnectStrategyDefault()
+        : new reconnect_strategy_1.MqttsReconnectStrategyDefault(0);
+    } else {
+      this.reconnectStrategy = options.autoReconnect;
+    }
+    this.transport =
+      options.transport ??
+      new transport_1.TlsTransport({
+        host: options.host,
+        port: options.port,
+        additionalOptions: {
+          enableTrace: options.enableTrace,
+        },
+      });
+    this.createTransformer =
+      options.createTransformer ??
+      (() =>
+        new mqtt_parser_1.MqttTransformer({
+          debug: this.mqttDebug.extend("transformer"),
+          mapping: options.readMap ?? packets_1.DefaultPacketReadMap,
+        }));
+    this.transformer = this.createTransformer();
+    this.transformer.options.debug ??= this.mqttDebug.extend("transformer");
+    const packetLogger = this.mqttDebug.extend("write");
+    this.writer =
+      options.packetWriter ??
+      new packets_1.PacketWriter(
+        {
+          logPacketWrite: (0, mqtt_utilities_1.createDefaultPacketLogger)(
+            packetLogger
+          ),
+        },
+        options.writeMap
+      );
+  }
+  async _connect(options) {
+    this.expectCreated();
+    this.mqttDebug(
+      `Connecting using transport "${this.transport.constructor.name}"`
+    );
+    this.connectResolver = options;
+    this.setConnecting();
+    try {
+      await this.transport.connect();
+    } catch (e) {
+      const err = tryMakeError(e);
+      this.mqttDebug(
+        `Transport connect error ("${this.transport.constructor.name}")`,
+        err.message
+      );
+      const shouldReconnect = this.reconnectStrategy?.check();
+      await this.setDisconnected(err);
+      if (shouldReconnect) {
+        return;
+      } else {
+        throw e;
+      }
+    }
+    this.createPipeline();
+    return this.registerClient(await this.resolveConnectOptions());
+  }
+  async connect(options) {
+    try {
+      await this._connect(options);
+    } catch (e) {
+      const err = tryMakeError(e);
+      this.mqttDebug(`Connection error`, err);
+      this.emitError(err);
+    }
+  }
+  createPipeline() {
+    if (!this.transport.duplex)
+      throw new errors_1.IllegalStateError(
+        "Expected transport to expose a Duplex."
+      );
+    this.pipeline = (0, stream_1.pipeline)(
+      this.transport.duplex,
+      this.transformer,
+      async (source) => {
+        for await (const chunk of source) {
+          if (!chunk.type) {
+            throw new Error("Chunk is not a MqttPacket");
+          }
+          await this.handlePacket(chunk);
         }
-    }
-    listenSubscribe(options, handlerFn) {
-        const listener = typeof options === 'string' ? { topic: options } : options;
-        return this.subscribe({
-            ...listener.subscriptionInfo,
-            topic: listener.topic.replace(/\/:[A-Za-z-_0-9]+/g, '/+'),
-        }).then(() => this.listen(listener, handlerFn));
-    }
-    listen(options, handlerFn) {
-        const listener = typeof options === 'string' ? { topic: options } : options;
-        const [topicFilter, paramMatcher] = (0, mqtt_utilities_1.toMqttTopicFilter)(listener.topic);
-        return this.messageListener.addHandler({
-            topicFilter,
-            handle: handlerFn,
-            transformer: listener.transformer,
-            validator: listener.validator,
-            paramMatcher,
-        });
-    }
-    startFlow(flow) {
-        const flowId = this.flowCounter.next();
-        const promise = new Promise((resolve, reject) => {
-            const data = {
-                resolvers: { resolve, reject },
-                finished: false,
-                callbacks: flow(
-                    value => {
-                        data.finished = true;
-                        resolve(value);
-                    },
-                    err => {
-                        data.finished = true;
-                        reject(err);
-                    },
-                ),
-                flowId,
-                flowFunc: flow,
-            };
-            const first = data.callbacks.start();
-            if (first) this.sendData(this.writer.write(first.type, first.options));
-            if (!data.finished) {
-                this.activeFlows.push(data);
-            }
-        });
-        promise.flowId = flowId;
-        return promise;
-    }
-    stopFlow(flowId, rejection) {
-        const flow = this.getFlowById(flowId);
-        if (!flow) return false;
-        this.activeFlows = this.activeFlows.filter(f => f.flowId !== flowId);
-        flow.finished = true;
-        flow.resolvers.reject(rejection ?? new errors_1.FlowStoppedError());
-        return true;
-    }
-    /**
-     *  Run the accept and next function of all active flows
-     * @param packet
-     * @returns true if a flow has been found
-     */
-    continueFlows(packet) {
-        let result = false;
-        for (const flow of this.activeFlows) {
-            if (flow.callbacks.accept?.(packet.data)) {
-                const next = flow.callbacks.next?.(packet.data);
-                if (next) {
-                    this.sendData(this.writer.write(next.type, next.options));
-                }
-                result = true;
-            }
+        return "Source drained";
+      } /* bad definitions */,
+      (err) => {
+        if (err) this.emitError(tryMakeError(err));
+        if (!this.disconnected) {
+          (err
+            ? this.setDisconnected(tryMakeError(err))
+            : this.setDisconnected("Pipeline finished")
+          ).catch((e) => this.emitWarning(e));
         }
-        this.clearFinishedFlows();
-        return result;
-    }
-    clearFinishedFlows() {
-        this.activeFlows = this.activeFlows.filter(flow => !flow.finished);
-    }
-    stopExecutingFlows(error) {
-        for (const flow of this.activeFlows) {
-            flow.resolvers.reject(error);
-            flow.finished = true;
+      }
+    );
+  }
+  publish(message) {
+    return this.startFlow((0, flow_1.outgoingPublishFlow)(message));
+  }
+  subscribe(subscription) {
+    return this.startFlow((0, flow_1.outgoingSubscribeFlow)(subscription));
+  }
+  unsubscribe(subscription) {
+    return this.startFlow((0, flow_1.outgoingUnsubscribeFlow)(subscription));
+  }
+  async disconnect(force = false) {
+    if (!force) {
+      return this.startFlow((0, flow_1.outgoingDisconnectFlow)()).then(
+        async () => {
+          await this.setDisconnected("Soft disconnect");
         }
-        this.activeFlows = [];
-    }
-    getFlowById(id) {
-        return this.activeFlows.find(f => f.flowId === id);
-    }
-    registerClient(options) {
-        const flow = this.getConnectFlow(options);
-        const connectPromiseFlow = this.startFlow(flow);
-        if (typeof options.connectDelay !== 'undefined') {
-            const timerId = this.executeDelayed(options.connectDelay ?? 2000, () => {
-                const flow = this.getFlowById(connectPromiseFlow.flowId);
-                if (!flow) {
-                    // there's no flow anymore
-                    this.stopExecuting(timerId);
-                    return;
-                }
-                const packet = flow.callbacks.start();
-                if (packet) this.sendData(this.writer.write(packet.type, packet.options));
-            });
-            connectPromiseFlow
-                .finally(() => this.stopExecuting(timerId))
-                // not sure why this is necessary, but it's there so no unhandledRejection is thrown
-                .catch(() => undefined);
+      );
+    } else {
+      await this.setDisconnected("Forced disconnect");
+    }
+  }
+  listenSubscribe(options, handlerFn) {
+    const listener = typeof options === "string" ? { topic: options } : options;
+    return this.subscribe({
+      ...listener.subscriptionInfo,
+      topic: listener.topic.replace(/\/:[A-Za-z-_0-9]+/g, "/+"),
+    }).then(() => this.listen(listener, handlerFn));
+  }
+  listen(options, handlerFn) {
+    const listener = typeof options === "string" ? { topic: options } : options;
+    const [topicFilter, paramMatcher] = (0, mqtt_utilities_1.toMqttTopicFilter)(
+      listener.topic
+    );
+    return this.messageListener.addHandler({
+      topicFilter,
+      handle: handlerFn,
+      transformer: listener.transformer,
+      validator: listener.validator,
+      paramMatcher,
+    });
+  }
+  startFlow(flow) {
+    const flowId = this.flowCounter.next();
+    const promise = new Promise((resolve, reject) => {
+      const data = {
+        resolvers: { resolve, reject },
+        finished: false,
+        callbacks: flow(
+          (value) => {
+            data.finished = true;
+            resolve(value);
+          },
+          (err) => {
+            data.finished = true;
+            reject(err);
+          }
+        ),
+        flowId,
+        flowFunc: flow,
+      };
+      const first = data.callbacks.start();
+      if (first) this.sendData(this.writer.write(first.type, first.options));
+      if (!data.finished) {
+        this.activeFlows.push(data);
+      }
+    });
+    promise.flowId = flowId;
+    return promise;
+  }
+  stopFlow(flowId, rejection) {
+    const flow = this.getFlowById(flowId);
+    if (!flow) return false;
+    this.activeFlows = this.activeFlows.filter((f) => f.flowId !== flowId);
+    flow.finished = true;
+    flow.resolvers.reject(rejection ?? new errors_1.FlowStoppedError());
+    return true;
+  }
+  /**
+   *  Run the accept and next function of all active flows
+   * @param packet
+   * @returns true if a flow has been found
+   */
+  continueFlows(packet) {
+    let result = false;
+    for (const flow of this.activeFlows) {
+      if (flow.callbacks.accept?.(packet.data)) {
+        const next = flow.callbacks.next?.(packet.data);
+        if (next) {
+          this.sendData(this.writer.write(next.type, next.options));
         }
-        options.signal?.addEventListener('abort', () => {
-            try {
-                this.stopFlow(connectPromiseFlow.flowId, new errors_1.AbortError('Connecting aborted'));
-            } catch (e) {
-                this.emitWarning(tryMakeError(e));
-            }
-        });
-        return connectPromiseFlow;
-    }
-    getConnectFlow(options) {
-        // assume the defaults are used
-        return (0, flow_1.outgoingConnectFlow)(options);
-    }
-    updateKeepAlive(value) {
-        value = Math.max(value - 0.5, 1);
-        if (this.keepAliveTimer) {
-            this.stopExecuting(this.keepAliveTimer);
-        }
-        this.mqttDebug(`Starting keep-alive-ping {delay: ${value}}`);
-        this.keepAliveTimer = this.executePeriodically(value * 1000, () => {
-            // assume the defaults are used
-            this.startFlow((0, flow_1.outgoingPingFlow)())
-                .then(() => this.pingDebug(`PingPong @ ${Date.now()}`))
-                .catch(e => {
-                    this.emitWarning(e);
-                    this.pingDebug(`PingPong failed. (${e.message})`);
-                });
-        });
-    }
-    sendData(data) {
-        if (!this.transport.duplex) {
-            this.emitError(new errors_1.IllegalStateError('Expected a duplex - was undefined'));
-            return;
-        }
-        this.transport.duplex.write(data);
-    }
-    async handlePacket(packet) {
-        this.logReceivedPacket(packet);
-        this.emit(mqtt_constants_1.PacketType[packet.type].toUpperCase(), packet.data);
-        let forceCheckFlows = false;
-        // The following "type assertions" are valid as clients extending MqttClient have to implement their own methods
-        switch (packet.type) {
-            case mqtt_constants_1.PacketType.ConnAck: {
-                this.onConnAck(packet.data);
-                break;
-            }
-            case mqtt_constants_1.PacketType.Publish: {
-                this.onPublish(packet.data);
-                break;
-            }
-            case mqtt_constants_1.PacketType.PingReq: {
-                this.onPingReq();
-                break;
-            }
-            case mqtt_constants_1.PacketType.Disconnect: {
-                this.setDisconnected('disconnect packet received').catch(e => this.emitWarning(e));
-                break;
-            }
-            default:
-                forceCheckFlows = true;
-        }
-        if (!this.continueFlows(packet) && forceCheckFlows) {
-            this.emitWarning(new errors_1.UnexpectedPacketError((0, mqtt_constants_1.packetTypeToString)(packet.type)));
-        }
-    }
-    onConnAck(connAck) {
-        if (connAck.isSuccess) {
-            this.setReady();
-            this.emitConnect(connAck);
-            if (this.connectOptions?.keepAlive) {
-                this.updateKeepAlive(this.connectOptions.keepAlive);
-            }
-            this.reconnectStrategy?.reset();
-        } else {
-            const error = new errors_1.ConnectError(connAck.errorName);
-            this.setDisconnected(error).catch(e => this.emitWarning(e));
-            this.emitError(error);
-        }
-    }
-    onPublish(publish) {
-        this.startFlow(
-            (0, flow_1.incomingPublishFlow)(
-                {
-                    topic: publish.topic,
-                    payload: publish.payload,
-                    qosLevel: publish.qos,
-                    retained: publish.retain,
-                    duplicate: publish.duplicate,
-                },
-                publish.identifier ?? undefined,
-            ),
-        )
-            .then(async m => {
-                this.emitMessage(m);
-                await this.messageListener.handleMessage(m);
-            })
-            .catch(e => this.emitWarning(e));
-    }
-    onPingReq() {
-        this.startFlow((0, flow_1.incomingPingFlow)())
-            .then(() => this.pingDebug(`Server-PingPong @ ${Date.now()}`))
-            .catch(e => {
-                this.emitWarning(e);
-                this.pingDebug(`Server-PingPong failed. (${e.message})`);
-            });
-    }
-    logReceivedPacket(packet) {
-        if (packet.type !== mqtt_constants_1.PacketType.PingReq && packet.type !== mqtt_constants_1.PacketType.PingResp)
-            this.receiveDebug(`Received ${(0, mqtt_utilities_1.stringifyObject)(packet.data)}`);
-    }
-    reset() {
-        super.reset();
+        result = true;
+      }
+    }
+    this.clearFinishedFlows();
+    return result;
+  }
+  clearFinishedFlows() {
+    this.activeFlows = this.activeFlows.filter((flow) => !flow.finished);
+  }
 
+  stopExecutingFlows(error) {
+    const flows = [...this.activeFlows];
+    this.activeFlows = [];
+
+    flows.forEach((flow) => {
+      flow.finished = true;
+
+      (async () => {
         try {
-            this.stopExecutingFlows(new errors_1.AbortError('Resetting'));
+          flow.resolvers.reject(error);
         } catch (e) {
-            this.emitWarning(tryMakeError(e));
+          this.mqttDebug?.("Flow rejection error during cleanup:", e);
         }
+      })().catch(() => {});
+    });
+  }
 
-        if (this.keepAliveTimer) {
-            clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = undefined;
+  getFlowById(id) {
+    return this.activeFlows.find((f) => f.flowId === id);
+  }
+  registerClient(options) {
+    const flow = this.getConnectFlow(options);
+    const connectPromiseFlow = this.startFlow(flow);
+    if (typeof options.connectDelay !== "undefined") {
+      const timerId = this.executeDelayed(options.connectDelay ?? 2000, () => {
+        const flow = this.getFlowById(connectPromiseFlow.flowId);
+        if (!flow) {
+          // there's no flow anymore
+          this.stopExecuting(timerId);
+          return;
         }
-        this.transformer.reset();
-    }
-    setReady() {
-        super.setReady();
-        this.mqttDebug('Ready!');
-    }
-    async reconnect() {
-        this.transport.reset();
-        this.transformer = this.createTransformer();
-        this.transformer.options.debug = this.transformer.options.debug ?? this.mqttDebug.extend('transformer');
-        await this.reconnectStrategy?.wait();
-        await this.connect();
+        const packet = flow.callbacks.start();
+        if (packet)
+          this.sendData(this.writer.write(packet.type, packet.options));
+      });
+      connectPromiseFlow
+        .finally(() => this.stopExecuting(timerId))
+        // not sure why this is necessary, but it's there so no unhandledRejection is thrown
+        .catch(() => undefined);
+    }
+    options.signal?.addEventListener("abort", () => {
+      try {
+        this.stopFlow(
+          connectPromiseFlow.flowId,
+          new errors_1.AbortError("Connecting aborted")
+        );
+      } catch (e) {
+        this.emitWarning(tryMakeError(e));
+      }
+    });
+    return connectPromiseFlow;
+  }
+  getConnectFlow(options) {
+    // assume the defaults are used
+    return (0, flow_1.outgoingConnectFlow)(options);
+  }
+  updateKeepAlive(value) {
+    value = Math.max(value - 0.5, 1);
+    if (this.keepAliveTimer) {
+      this.stopExecuting(this.keepAliveTimer);
+    }
+    this.mqttDebug(`Starting keep-alive-ping {delay: ${value}}`);
+    this.keepAliveTimer = this.executePeriodically(value * 1000, () => {
+      // assume the defaults are used
+      this.startFlow((0, flow_1.outgoingPingFlow)())
+        .then(() => this.pingDebug(`PingPong @ ${Date.now()}`))
+        .catch((e) => {
+          this.emitWarning(e);
+          this.pingDebug(`PingPong failed. (${e.message})`);
+        });
+    });
+  }
+  sendData(data) {
+    if (!this.transport.duplex) {
+      this.emitError(
+        new errors_1.IllegalStateError("Expected a duplex - was undefined")
+      );
+      return;
+    }
+    this.transport.duplex.write(data);
+  }
+  async handlePacket(packet) {
+    this.logReceivedPacket(packet);
+    this.emit(
+      mqtt_constants_1.PacketType[packet.type].toUpperCase(),
+      packet.data
+    );
+    let forceCheckFlows = false;
+    // The following "type assertions" are valid as clients extending MqttClient have to implement their own methods
+    switch (packet.type) {
+      case mqtt_constants_1.PacketType.ConnAck: {
+        this.onConnAck(packet.data);
+        break;
+      }
+      case mqtt_constants_1.PacketType.Publish: {
+        this.onPublish(packet.data);
+        break;
+      }
+      case mqtt_constants_1.PacketType.PingReq: {
+        this.onPingReq();
+        break;
+      }
+      case mqtt_constants_1.PacketType.Disconnect: {
+        this.setDisconnected("disconnect packet received").catch((e) =>
+          this.emitWarning(e)
+        );
+        break;
+      }
+      default:
+        forceCheckFlows = true;
+    }
+    if (!this.continueFlows(packet) && forceCheckFlows) {
+      this.emitWarning(
+        new errors_1.UnexpectedPacketError(
+          (0, mqtt_constants_1.packetTypeToString)(packet.type)
+        )
+      );
+    }
+  }
+  onConnAck(connAck) {
+    if (connAck.isSuccess) {
+      this.setReady();
+      this.emitConnect(connAck);
+      if (this.connectOptions?.keepAlive) {
+        this.updateKeepAlive(this.connectOptions.keepAlive);
+      }
+      this.reconnectStrategy?.reset();
+    } else {
+      const error = new errors_1.ConnectError(connAck.errorName);
+      this.setDisconnected(error).catch((e) => this.emitWarning(e));
+      this.emitError(error);
+    }
+  }
+  onPublish(publish) {
+    this.startFlow(
+      (0, flow_1.incomingPublishFlow)(
+        {
+          topic: publish.topic,
+          payload: publish.payload,
+          qosLevel: publish.qos,
+          retained: publish.retain,
+          duplicate: publish.duplicate,
+        },
+        publish.identifier ?? undefined
+      )
+    )
+      .then(async (m) => {
+        this.emitMessage(m);
+        await this.messageListener.handleMessage(m);
+      })
+      .catch((e) => this.emitWarning(e));
+  }
+  onPingReq() {
+    this.startFlow((0, flow_1.incomingPingFlow)())
+      .then(() => this.pingDebug(`Server-PingPong @ ${Date.now()}`))
+      .catch((e) => {
+        this.emitWarning(e);
+        this.pingDebug(`Server-PingPong failed. (${e.message})`);
+      });
+  }
+  logReceivedPacket(packet) {
+    if (
+      packet.type !== mqtt_constants_1.PacketType.PingReq &&
+      packet.type !== mqtt_constants_1.PacketType.PingResp
+    )
+      this.receiveDebug(
+        `Received ${(0, mqtt_utilities_1.stringifyObject)(packet.data)}`
+      );
+  }
+  reset() {
+    super.reset();
+
+    try {
+      this.stopExecutingFlows(new errors_1.AbortError("Resetting"));
+    } catch (e) {
+      this.emitWarning(tryMakeError(e));
     }
-    async setDisconnected(reason) {
-        const willReconnect = this.reconnectStrategy?.check(reason) ?? false;
-        this.mqttDebug(`Disconnected. Will reconnect: ${willReconnect}`);
-        this._setDisconnected();
 
-        try {
-            this.stopExecutingFlows(new errors_1.AbortError('Client disconnected.'));
-        } catch (e) {
-            this.emitWarning(tryMakeError(e));
-        }
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = undefined;
+    }
+    this.transformer.reset();
+  }
+  setReady() {
+    super.setReady();
+    this.mqttDebug("Ready!");
+  }
+  async reconnect() {
+    this.transport.reset();
+    this.transformer = this.createTransformer();
+    this.transformer.options.debug =
+      this.transformer.options.debug ?? this.mqttDebug.extend("transformer");
+    await this.reconnectStrategy?.wait();
+    await this.connect();
+  }
+  async setDisconnected(reason) {
+    const willReconnect = this.reconnectStrategy?.check(reason) ?? false;
+    this.mqttDebug(`Disconnected. Will reconnect: ${willReconnect}`);
+    this._setDisconnected();
 
-        this.emitDisconnect({ reason, reconnect: willReconnect });
-        if (this.transport.active) {
-            await new Promise(resolve => this.transport.duplex?.end(resolve) ?? /* never */ resolve());
-            if (this.transport.duplex && !this.transport.duplex.writableEnded) {
-                this.transport.duplex.destroy(new Error('force destroy'));
-            }
-        }
-        this.stopExecuting(this.keepAliveTimer);
-        this.reset();
-        if (willReconnect) {
-            await this.reconnect();
-        }
+    try {
+      this.stopExecutingFlows(new errors_1.AbortError("Client disconnected."));
+    } catch (e) {
+      this.emitWarning(tryMakeError(e));
     }
+
+    this.emitDisconnect({ reason, reconnect: willReconnect });
+    if (this.transport.active) {
+      await new Promise(
+        (resolve) =>
+          this.transport.duplex?.end(resolve) ?? /* never */ resolve()
+      );
+      if (this.transport.duplex && !this.transport.duplex.writableEnded) {
+        this.transport.duplex.destroy(new Error("force destroy"));
+      }
+    }
+    this.stopExecuting(this.keepAliveTimer);
+    this.reset();
+    if (willReconnect) {
+      await this.reconnect();
+    }
+  }
 }
 exports.MqttClient = MqttClient;
 //# sourceMappingURL=mqtt.client.js.map

package/package.json

@@ -1,74 +1,74 @@
 {
-    "name": "abmqtt-dist",
-    "version": "0.0.4",
-    "description": "MQTT client in Typescript",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "files": [
-        "dist"
-    ],
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/ozanbaskan/mqtts"
-    },
-    "bugs": {
-        "url": "https://github.com/ozanbaskan/mqtts/issues"
-    },
-    "scripts": {
-        "test": "jest",
-        "build": "",
-        "prepare": "npm run build",
-        "lint-fix": "eslint --fix --ext .js,.ts src/**",
-        "lint": "eslint --ext .js,.ts src/**",
-        "format": "prettier -w . --loglevel warn",
-        "check-format": "prettier -c .",
-        "typecheck": "tsc -p tsconfig.build.json --noEmit",
-        "precommit": "pnpm run typecheck && pnpm run lint && pnpm run format"
-    },
-    "dependencies": {
-        "@types/ws": "^8.5.10",
-        "debug": "^4.3.4",
-        "eventemitter3": "^5.0.1",
-        "socks": "^2.8.1",
-        "ts-custom-error": "^3.3.1",
-        "ts-xor": "^1.3.0",
-        "ws": "^8.16.0"
-    },
-    "devDependencies": {
-        "@swc/core": "^1.4.12",
-        "@swc/jest": "^0.2.36",
-        "@types/chai": "^4.3.14",
-        "@types/chai-as-promised": "^7.1.8",
-        "@types/debug": "^4.1.12",
-        "@types/duplexify": "^3.6.4",
-        "@types/jest": "^29.5.12",
-        "@types/node": "^18.11.9",
-        "@types/sinon": "^17.0.3",
-        "@typescript-eslint/eslint-plugin": "^7.5.0",
-        "@typescript-eslint/parser": "^7.5.0",
-        "chai": "^4.4.1 < 5",
-        "chai-as-promised": "^7.1.1",
-        "duplexify": "^4.1.3",
-        "eslint": "^8.57.0",
-        "jest": "^29.7.0",
-        "prettier": "^3.2.5",
-        "rimraf": "^5.0.5",
-        "sinon": "^17.0.1",
-        "ts-jest": "^29.1.2",
-        "typescript": "^5.4.4"
-    },
-    "keywords": [
-        "MQTT",
-        "subscribe",
-        "iot",
-        "tls"
-    ],
-    "author": {
-        "name": "Ozan Baskan",
-        "email": "ozanbaskan7@gmail.com"
-    },
-    "license": "MIT"
+  "name": "abmqtt-dist",
+  "version": "0.0.6",
+  "description": "MQTT client in Typescript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ozanbaskan/mqtts"
+  },
+  "bugs": {
+    "url": "https://github.com/ozanbaskan/mqtts/issues"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "",
+    "prepare": "npm run build",
+    "lint-fix": "eslint --fix --ext .js,.ts src/**",
+    "lint": "eslint --ext .js,.ts src/**",
+    "format": "prettier -w . --loglevel warn",
+    "check-format": "prettier -c .",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "precommit": "pnpm run typecheck && pnpm run lint && pnpm run format"
+  },
+  "dependencies": {
+    "@types/ws": "^8.5.10",
+    "debug": "^4.3.4",
+    "eventemitter3": "^5.0.1",
+    "socks": "^2.8.1",
+    "ts-custom-error": "^3.3.1",
+    "ts-xor": "^1.3.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.4.12",
+    "@swc/jest": "^0.2.36",
+    "@types/chai": "^4.3.14",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/debug": "^4.1.12",
+    "@types/duplexify": "^3.6.4",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^18.11.9",
+    "@types/sinon": "^17.0.3",
+    "@typescript-eslint/eslint-plugin": "^7.5.0",
+    "@typescript-eslint/parser": "^7.5.0",
+    "chai": "^4.4.1 < 5",
+    "chai-as-promised": "^7.1.1",
+    "duplexify": "^4.1.3",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "sinon": "^17.0.1",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.4"
+  },
+  "keywords": [
+    "MQTT",
+    "subscribe",
+    "iot",
+    "tls"
+  ],
+  "author": {
+    "name": "Ozan Baskan",
+    "email": "ozanbaskan7@gmail.com"
+  },
+  "license": "MIT"
 }