@seriousme/opifex 1.2.1 → 1.4.0

package/dist/bin/mqtt.js

@@ -1,54 +1,8 @@
-#!/usr/bin/env node
-import { C as Client, D as DEFAULT_URL } from "../client-DqLTBVC2.js";
-import { L as LogLevel, l as logger } from "../timer-DDWVNsyG.js";
-import {
-  g as getArgs,
-  p as parseArgs,
-  w as wrapNodeSocket,
-} from "../wrapNodeSocket-BAJm059T.js";
-import "node:process";
-import { readFile } from "node:fs/promises";
-import { connect } from "node:net";
-import * as tls from "node:tls";
-import "node:stream";
-
-async function getCaCerts(filename) {
-  if (!filename) {
-    return;
-  }
-  const caCerts = await readFile(filename, { encoding: "utf-8" });
-  if (caCerts === "") {
-    return;
-  }
-  return [caCerts];
-}
-class TcpClient extends Client {
-  async connectMQTT(hostname, port = 1883) {
-    logger.debug({ hostname, port });
-    return wrapNodeSocket(await connect({ host: hostname, port }));
-  }
-  async connectMQTTS(hostname, port = 8883, caCerts) {
-    const opts = {
-      host: hostname,
-      port,
-      secureContext: caCerts
-        ? tls.createSecureContext({ cert: caCerts })
-        : void 0,
-    };
-    logger.debug({ hostname, port, caCerts });
-    return wrapNodeSocket(await tls.connect(opts));
-  }
-  createConn(protocol, hostname, port, caCerts) {
-    if (protocol === "mqtts:") {
-      return this.connectMQTTS(hostname, port, caCerts);
-    }
-    if (protocol === "mqtt:") {
-      return this.connectMQTT(hostname, port);
-    }
-    throw `Unsupported protocol: ${protocol}`;
-  }
-}
-
+#!/usr/bin/env -S node --experimental-strip-types
+import { DEFAULT_URL } from "../client/mod.js";
+import { logger, LogLevel } from "../utils/mod.js";
+import { getArgs, parseArgs } from "../utils/mod.js";
+import { getCaCerts, TcpClient } from "../node/client.js";
 const client = new TcpClient();
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -69,20 +23,21 @@ const ConnectHelp = `
   -h/--help       this text
   `;
 const connectOpts = {
-  string: ["url", "username", "password", "certFile", "clientId"],
-  alias: {
-    u: "url",
-    U: "username",
-    P: "password",
-    c: "certFile",
-    i: "clientId",
-    n: "noClean",
-    h: "help",
-  },
-  boolean: ["noClean", "help"],
-  default: {
-    noClean: false,
-  },
+    string: ["url", "username", "password", "certFile", "clientId"],
+    alias: {
+        u: "url",
+        U: "username",
+        P: "password",
+        c: "certFile",
+        i: "clientId",
+        n: "noClean",
+        h: "help",
+    },
+    boolean: ["noClean", "help"],
+    default: {
+        noClean: false,
+        clientId: `Opifex-${crypto.randomUUID()}`,
+    },
 };
 const SubscribeHelp = `Usage: mqtt subscribe <options>
 
@@ -92,71 +47,75 @@ Where options are:
 ${ConnectHelp}
 Example: mqtt subscribe -t hello`;
 const subscribeOpts = {
-  string: ["topic"],
-  alias: {
-    t: "topic",
-    q: "qos",
-  },
-  default: {
-    qos: 0,
-    topic: "",
-  },
+    string: ["topic"],
+    alias: {
+        t: "topic",
+        q: "qos",
+    },
+    default: {
+        qos: 0,
+        topic: "",
+    },
 };
 function parseQos(qosArg) {
-  const qos = Number(qosArg);
-  switch (qos) {
-    case 0:
-      return 0;
-    case 1:
-      return 1;
-    case 2:
-      return 2;
-  }
-  console.log("QoS must be between 0 and 2");
-  return 0;
+    const qos = Number(qosArg);
+    switch (qos) {
+        case 0:
+            return 0;
+        case 1:
+            return 1;
+        case 2:
+            return 2;
+        default:
+            break;
+    }
+    console.log("QoS must be between 0 and 2");
+    return 0;
 }
 async function subscribe() {
-  const connectArgs = parseArgs(getArgs(), connectOpts);
-  const caCerts = await getCaCerts(connectArgs.certFile);
-  const subscribeArgs = parseArgs(getArgs(), subscribeOpts);
-  if (connectArgs.help) {
-    console.log(SubscribeHelp);
-    return;
-  }
-  if (subscribeArgs.topic === void 0) {
-    console.log("Missing `topic`");
-    return;
-  }
-  try {
-    await client.connect({
-      url: connectArgs.url,
-      caCerts,
-      options: {
-        username: connectArgs.username,
-        password: encoder.encode(connectArgs.password),
-        clientId: connectArgs.clientId,
-        clean: !connectArgs.noClean,
-        keepAlive: 60,
-      },
-    });
-    logger.debug("Connected !");
-    client.subscribe({
-      subscriptions: [
-        {
-          topicFilter: subscribeArgs.topic,
-          qos: parseQos(subscribeArgs.qos),
-        },
-      ],
-    });
-    logger.debug("Subscribed!");
-    for await (const message of client.messages()) {
-      console.log(decoder.decode(message.payload));
+    const connectArgs = parseArgs(getArgs(), connectOpts);
+    const caCerts = await getCaCerts(connectArgs.certFile);
+    const subscribeArgs = parseArgs(getArgs(), subscribeOpts);
+    if (connectArgs.help) {
+        console.log(SubscribeHelp);
+        return;
     }
-  } catch (err) {
-    if (err instanceof Error) {
-      logger.info(err.message);
+    if (subscribeArgs.topic === undefined) {
+        console.log("Missing `topic`");
+        return;
+    }
+    try {
+        await client.connect({
+            url: connectArgs.url,
+            caCerts,
+            options: {
+                username: connectArgs.username,
+                password: encoder.encode(connectArgs.password),
+                clientId: connectArgs.clientId,
+                clean: !connectArgs.noClean,
+                keepAlive: 60,
+            },
+        });
+        logger.debug("Connected !");
+        client.subscribe({
+            subscriptions: [
+                {
+                    topicFilter: subscribeArgs.topic,
+                    qos: parseQos(subscribeArgs.qos),
+                },
+            ],
+        });
+        logger.debug("Subscribed!");
+        for await (const message of client.messages()) {
+            console.log(decoder.decode(message.payload));
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            // @ts-ignore the type spec of err is missing err.code
+            logger.info(`Error: ${err.message || err.code}`);
+        }
     }
-  }
 }
 const PublishHelp = `Usage: mqtt publish <options>
 
@@ -168,73 +127,75 @@ Where options are:
 ${ConnectHelp}
 Example: mqtt publish -t hello -m world`;
 const publishOpts = {
-  string: ["topic", "message"],
-  boolean: ["retain"],
-  alias: {
-    t: "topic",
-    m: "message",
-    q: "qos",
-    r: "retain",
-  },
-  default: {
-    qos: 0,
-    dup: false,
-    retain: false,
-    topic: void 0,
-    message: "",
-  },
+    string: ["topic", "message"],
+    boolean: ["retain"],
+    alias: {
+        t: "topic",
+        m: "message",
+        q: "qos",
+        r: "retain",
+    },
+    default: {
+        qos: 0,
+        dup: false,
+        retain: false,
+        topic: undefined,
+        message: "",
+    },
 };
 async function publish() {
-  const connectArgs = parseArgs(getArgs(), connectOpts);
-  const caCerts = await getCaCerts(connectArgs.certFile);
-  const publishArgs = parseArgs(getArgs(), publishOpts);
-  if (connectArgs.help) {
-    console.log(PublishHelp);
-    return;
-  }
-  if (publishArgs.topic === void 0) {
-    console.log("Missing `topic`");
-    return;
-  }
-  try {
-    await client.connect({
-      url: connectArgs.url,
-      caCerts,
-      options: {
-        username: connectArgs.username,
-        password: encoder.encode(connectArgs.password),
-        clientId: connectArgs.clientId,
-        clean: !connectArgs.noClean,
-      },
-    });
-    logger.debug("Connected !");
-    await client.publish({
-      topic: publishArgs.topic,
-      payload: encoder.encode(publishArgs.message),
-      retain: publishArgs.retain,
-      qos: parseQos(publishArgs.qos),
-    });
-    logger.debug("Published!");
-    client.disconnect();
-    logger.debug("Disconnected !");
-  } catch (err) {
-    if (err instanceof Error) {
-      logger.info(err.message);
+    const connectArgs = parseArgs(getArgs(), connectOpts);
+    const caCerts = await getCaCerts(connectArgs.certFile);
+    const publishArgs = parseArgs(getArgs(), publishOpts);
+    if (connectArgs.help) {
+        console.log(PublishHelp);
+        return;
+    }
+    if (publishArgs.topic === undefined) {
+        console.log("Missing `topic`");
+        return;
+    }
+    try {
+        await client.connect({
+            url: connectArgs.url,
+            caCerts,
+            options: {
+                username: connectArgs.username,
+                password: encoder.encode(connectArgs.password),
+                clientId: connectArgs.clientId,
+                clean: !connectArgs.noClean,
+            },
+        });
+        logger.debug("Connected !");
+        await client.publish({
+            topic: publishArgs.topic,
+            payload: encoder.encode(publishArgs.message),
+            retain: publishArgs.retain,
+            qos: parseQos(publishArgs.qos),
+        });
+        logger.debug("Published!");
+        client.disconnect();
+        logger.debug("Disconnected !");
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            // @ts-ignore the type spec of err is missing err.code
+            logger.info(`Error: ${err.message || err.code}`);
+        }
     }
-  }
 }
 function processArgs() {
-  const { _: [cmd] } = parseArgs(getArgs());
-  switch (cmd) {
-    case "publish":
-      publish();
-      break;
-    case "subscribe":
-      subscribe();
-      break;
-    default:
-      console.log(MQTTHelp);
-      break;
-  }
+    const { _: [cmd] } = parseArgs(getArgs());
+    switch (cmd) {
+        case "publish":
+            publish();
+            break;
+        case "subscribe":
+            subscribe();
+            break;
+        default:
+            console.log(MQTTHelp);
+            break;
+    }
 }
 processArgs();

package/dist/client/ConnectionState.js

@@ -0,0 +1,7 @@
+export const ConnectionState = {
+    offline: "offline",
+    connecting: "connecting",
+    connected: "connected",
+    disconnecting: "disconnecting",
+    disconnected: "disconnected",
+};

package/dist/client/client.js

@@ -0,0 +1,129 @@
+import { Deferred, logger, MemoryStore, PacketType, } from "./deps.js";
+import { Context } from "./context.js";
+function generateClientId(prefix) {
+    return `${prefix}-${Math.random().toString().slice(-10)}`;
+}
+function backOffSleep(random, attempt) {
+    // based on https://dthain.blogspot.com/2009/02/exponential-backoff-in-distributed.html
+    const factor = 1.5;
+    const min = 1000;
+    const max = 5000;
+    const randomness = 1 + (random ? Math.random() : 0);
+    const delay = Math.floor(Math.min(randomness * min * (factor ** attempt), max));
+    logger.debug({ delay });
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+/**  the default MQTT URL to connect to */
+export const DEFAULT_URL = "mqtt://localhost:1883/";
+const DEFAULT_KEEPALIVE = 60; // 60 seconds
+const DEFAULT_RETRIES = 3; // on first connect
+const CLIENTID_PREFIX = "opifex"; // on first connect
+/**
+ * The Client class provides an MQTT Client that can be used to connect to
+ * a MQTT broker and publish/subscribe messages.
+ *
+ * The Client class is not meant to be used directly, but
+ * instead should be subclassed and the subclass should
+ * override the createConn() method to provide a
+ * connection type that is supported by the subclass.
+ */
+export class Client {
+    clientIdPrefix = CLIENTID_PREFIX;
+    numberOfRetries = DEFAULT_RETRIES;
+    url = new URL(DEFAULT_URL);
+    keepAlive = DEFAULT_KEEPALIVE;
+    autoReconnect = true;
+    caCerts;
+    cert;
+    key;
+    clientId;
+    ctx = new Context(new MemoryStore());
+    connectPacket;
+    constructor() {
+        this.clientId = generateClientId(this.clientIdPrefix);
+        this.numberOfRetries = DEFAULT_RETRIES;
+    }
+    createConn(protocol, _hostname, _port, _caCerts, _cert, _key) {
+        // if you need to support alternative connection types just
+        // overload this method in your subclass
+        throw `Unsupported protocol: ${protocol}`;
+    }
+    async doConnect() {
+        if (!this.connectPacket) {
+            return;
+        }
+        let isReconnect = false;
+        let attempt = 1;
+        let lastMessage = new Error();
+        let tryConnect = true;
+        while (tryConnect) {
+            logger.debug(`${isReconnect ? "re" : ""}connecting`);
+            try {
+                const conn = await this.createConn(this.url.protocol, this.url.hostname, Number(this.url.port) ?? undefined, this.caCerts, this.cert, this.key);
+                // if we get this far we have a connection
+                tryConnect =
+                    (await this.ctx.handleConnection(conn, this.connectPacket)) &&
+                        this.autoReconnect;
+                logger.debug({ tryConnect });
+                isReconnect = true;
+                this.connectPacket.clean = false;
+                this.ctx.close();
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    lastMessage = err;
+                }
+                logger.debug(lastMessage);
+                if (!isReconnect && attempt > this.numberOfRetries) {
+                    tryConnect = false;
+                }
+                else {
+                    await backOffSleep(true, attempt++);
+                }
+            }
+        }
+        if (isReconnect === false) {
+            this.ctx.unresolvedConnect?.reject(lastMessage);
+        }
+    }
+    connect(params = {}) {
+        this.url = params?.url || this.url;
+        this.numberOfRetries = params.numberOfRetries || this.numberOfRetries;
+        this.caCerts = params?.caCerts;
+        this.cert = params?.cert;
+        this.key = params?.key;
+        const options = Object.assign({
+            keepAlive: this.keepAlive,
+            clientId: this.clientId,
+        }, params?.options);
+        this.connectPacket = {
+            type: PacketType.connect,
+            ...options,
+        };
+        const deferred = new Deferred();
+        this.ctx.unresolvedConnect = deferred;
+        this.doConnect();
+        return deferred.promise;
+    }
+    async disconnect() {
+        await this.ctx.disconnect();
+    }
+    async publish(params) {
+        const packet = {
+            type: PacketType.publish,
+            ...params,
+        };
+        await this.ctx.send(packet);
+    }
+    async subscribe(params) {
+        const packet = {
+            type: PacketType.subscribe,
+            id: this.ctx.store.nextId(),
+            ...params,
+        };
+        await this.ctx.send(packet);
+    }
+    async *messages() {
+        yield* this.ctx.incoming;
+    }
+}

package/dist/client/context.js

@@ -0,0 +1,148 @@
+import { AsyncQueue, Deferred, logger, MqttConn, PacketType, Timer, } from "./deps.js";
+import { handlePacket } from "./handlers/handlePacket.js";
+import { ConnectionState } from "./ConnectionState.js";
+export class Context {
+    mqttConn;
+    connectionState;
+    pingTimer;
+    unresolvedConnect;
+    unresolvedPublish;
+    unresolvedSubscribe;
+    unresolvedUnSubscribe;
+    store;
+    incoming;
+    constructor(store) {
+        this.store = store;
+        this.connectionState = ConnectionState.offline;
+        this.incoming = new AsyncQueue();
+        this.unresolvedPublish = new Map();
+        this.unresolvedSubscribe = new Map();
+        this.unresolvedUnSubscribe = new Map();
+    }
+    async connect(packet) {
+        this.connectionState = ConnectionState.connecting;
+        await this.mqttConn?.send(packet);
+        const keepAlive = packet.keepAlive || 0;
+        if (keepAlive > 0) {
+            this.pingTimer = new Timer(this.sendPing.bind(this), keepAlive * 1000, true);
+        }
+    }
+    async disconnect() {
+        if (this.connectionState !== ConnectionState.connected) {
+            throw "Not connected";
+        }
+        if (this.mqttConn) {
+            this.connectionState = ConnectionState.disconnecting;
+            await this.mqttConn.send({ type: PacketType.disconnect });
+            this.mqttConn.close();
+        }
+    }
+    async send(packet) {
+        logger.debug({ send: packet });
+        if (this.connectionState === ConnectionState.connected &&
+            !this.mqttConn?.isClosed) {
+            await this.mqttConn?.send(packet);
+            this.pingTimer?.reset();
+            return;
+        }
+        logger.debug("not connected");
+        this.pingTimer?.clear();
+    }
+    sendPing() {
+        this.send({ type: PacketType.pingreq });
+    }
+    async handleConnection(conn, connectPacket) {
+        this.mqttConn = new MqttConn({ conn });
+        if (this.mqttConn === undefined) {
+            return true;
+        }
+        logger.debug("Send connect packet");
+        await this.connect(connectPacket);
+        try {
+            logger.debug("Accepting packets");
+            for await (const packet of this.mqttConn) {
+                handlePacket(this, packet);
+            }
+            logger.debug("No more packets");
+        }
+        catch (err) {
+            logger.debug(err);
+            if (this.mqttConn.isClosed) {
+                this.mqttConn.close();
+            }
+        }
+        if (this.connectionState === ConnectionState.disconnecting) {
+            return false;
+        }
+        return true;
+    }
+    close() {
+        logger.debug("closing connection");
+        this.connectionState = ConnectionState.disconnected;
+        this.pingTimer?.clear();
+    }
+    receivePublish(packet) {
+        this.incoming.push(packet);
+    }
+    publish(packet) {
+        const qos = packet.qos || 0;
+        if (qos === 0) {
+            packet.id = 0;
+            this.send(packet);
+            // return empty promise
+            return Promise.resolve();
+        }
+        packet.id = this.store.nextId();
+        this.store.pendingOutgoing.set(packet.id, packet);
+        const deferred = new Deferred();
+        this.unresolvedPublish.set(packet.id, deferred);
+        this.send(packet);
+        return deferred.promise;
+    }
+    subscribe(packet) {
+        packet.id = this.store.nextId();
+        this.store.pendingOutgoing.set(packet.id, packet);
+        const deferred = new Deferred();
+        this.unresolvedSubscribe.set(packet.id, deferred);
+        this.send(packet);
+        return deferred.promise;
+    }
+    unsubscribe(packet) {
+        packet.id = this.store.nextId();
+        this.store.pendingOutgoing.set(packet.id, packet);
+        const deferred = new Deferred();
+        this.unresolvedUnSubscribe.set(packet.id, deferred);
+        this.send(packet);
+        return deferred.promise;
+    }
+    receivePuback(id) {
+        const unresolvedMap = this.unresolvedPublish;
+        if (unresolvedMap.has(id)) {
+            const deferred = unresolvedMap.get(id);
+            unresolvedMap.delete(id);
+            deferred?.resolve();
+            return true;
+        }
+        return false;
+    }
+    receiveSuback(id, returnCodes) {
+        const unresolvedMap = this.unresolvedSubscribe;
+        if (unresolvedMap.has(id)) {
+            const deferred = unresolvedMap.get(id);
+            unresolvedMap.delete(id);
+            deferred?.resolve(returnCodes);
+            return true;
+        }
+        return false;
+    }
+    receiveUnsuback(id) {
+        const unresolvedMap = this.unresolvedUnSubscribe;
+        if (unresolvedMap.has(id)) {
+            const deferred = unresolvedMap.get(id);
+            unresolvedMap.delete(id);
+            deferred?.resolve();
+            return true;
+        }
+        return false;
+    }
+}

package/dist/client/deps.js

@@ -0,0 +1,5 @@
+export { AuthenticationResult, AuthenticationResultByNumber, decodePayload, encode, PacketNameByType, PacketType, } from "../mqttPacket/mod.js";
+export { MqttConn } from "../mqttConn/mqttConn.js";
+export { Timer } from "../timer/timer.js";
+export { AsyncQueue, Deferred, logger } from "../utils/mod.js";
+export { MemoryStore } from "./store/memoryStore.js";

package/dist/client/handlers/handleConnack.js

@@ -0,0 +1,18 @@
+import { ConnectionState } from "../ConnectionState.js";
+import { AuthenticationResultByNumber } from "../deps.js";
+export async function handleConnack(packet, ctx) {
+    if (packet.returnCode === 0) {
+        ctx.connectionState = ConnectionState.connected;
+        ctx.pingTimer?.reset();
+        ctx.unresolvedConnect?.resolve(packet.returnCode);
+        // start transmitting packets that were queued before
+        for await (const packet of ctx.store.pendingOutgoingPackets()) {
+            ctx.send(packet);
+        }
+        return;
+    }
+    const err = new Error(`Connect failed: ${AuthenticationResultByNumber[packet.returnCode]}`);
+    ctx.connectionState = ConnectionState.disconnecting;
+    ctx.pingTimer?.clear();
+    ctx.unresolvedConnect?.reject(err);
+}