@seriousme/opifex 1.2.1 → 1.3.0

package/dist/mqttPacket/length.js

@@ -0,0 +1,43 @@
+export function encodeLength(n) {
+    const output = [];
+    let x = n;
+    do {
+        let encodedByte = x % 0x80;
+        x = Math.floor(x / 0x80);
+        if (x > 0) {
+            encodedByte = encodedByte | 0x80;
+        }
+        output.push(encodedByte);
+    } while (x > 0);
+    if (output.length > 4) {
+        throw Error("length encoding failed");
+    }
+    return output;
+}
+export function decodeLength(buf, start) {
+    const decode = getLengthDecoder();
+    const lenBuf = buf.subarray(start);
+    for (const byte of lenBuf) {
+        const { done, length, numLengthBytes } = decode(byte);
+        if (done) {
+            return { length, numLengthBytes };
+        }
+    }
+    throw Error("length decoding failed");
+}
+export function getLengthDecoder() {
+    let numLengthBytes = 1;
+    let length = 0;
+    let multiplier = 1;
+    return function addLengthByte(encodedByte) {
+        length += (encodedByte & 0x7f) * multiplier;
+        multiplier *= 0x80;
+        if ((encodedByte & 0x80) === 0) {
+            return { done: true, length, numLengthBytes };
+        }
+        if (numLengthBytes++ >= 4) {
+            throw Error("length decoding failed");
+        }
+        return { done: false, length, numLengthBytes };
+    };
+}

package/dist/mqttPacket/mod.js

@@ -0,0 +1,71 @@
+import { PacketNameByType, PacketType } from "./PacketType.js";
+import { invalidTopic, invalidTopicFilter, invalidUTF8 } from "./validators.js";
+import { decodeLength, encodeLength } from "./length.js";
+import connect from "./connect.js";
+import connack from "./connack.js";
+import { AuthenticationResult, AuthenticationResultByNumber, } from "./AuthenticationResult.js";
+import publish from "./publish.js";
+import puback from "./puback.js";
+import pubrec from "./pubrec.js";
+import pubrel from "./pubrel.js";
+import pubcomp from "./pubcomp.js";
+import subscribe from "./subscribe.js";
+import suback from "./suback.js";
+import unsubscribe from "./unsubscribe.js";
+import unsuback from "./unsuback.js";
+import pingreq from "./pingreq.js";
+import pingres from "./pingres.js";
+import disconnect from "./disconnect.js";
+import { DecoderError } from "./decoder.js";
+export { AuthenticationResult, AuthenticationResultByNumber, decodeLength, encodeLength, invalidTopic, invalidTopicFilter, invalidUTF8, PacketNameByType, PacketType, };
+export const packetsByType = [
+    null,
+    connect, // 1
+    connack, // 2
+    publish, // 3
+    puback, // 4
+    pubrec, // 5
+    pubrel, // 6
+    pubcomp, // 7
+    subscribe, // 8
+    suback, // 9
+    unsubscribe, // 10
+    unsuback, // 11
+    pingreq, // 12
+    pingres, // 13
+    disconnect, // 14
+];
+export function encode(packet) {
+    const packetType = packet.type;
+    // deno-lint-ignore no-explicit-any
+    const pkt = packet;
+    const encoded = packetsByType[packetType]?.encode(pkt);
+    if (!encoded) {
+        throw Error("Packet encoding failed");
+    }
+    const { flags, bytes } = encoded;
+    return Uint8Array.from([
+        (packetType << 4) | flags,
+        ...encodeLength(bytes.length),
+        ...bytes,
+    ]);
+}
+export function decodePayload(firstByte, buffer) {
+    const packetType = firstByte >> 4;
+    const flags = firstByte & 0x0f;
+    const packet = packetsByType[packetType]?.decode(buffer, flags);
+    if (packet !== undefined) {
+        return packet;
+    }
+    throw new Error("packet decoding failed");
+}
+export function decode(buffer) {
+    if (buffer.length < 2) {
+        throw new DecoderError("Packet decoding failed");
+    }
+    const { length, numLengthBytes } = decodeLength(buffer, 1);
+    const start = numLengthBytes + 1;
+    const end = start + length;
+    return decodePayload(buffer[0], buffer.subarray(start, end));
+}
+export { getLengthDecoder } from "../mqttPacket/length.js";

package/dist/mqttPacket/pingreq.js

@@ -0,0 +1,15 @@
+import { PacketType } from "./PacketType.js";
+import { hasEmptyFlags, isEmptyBuf } from "./decoder.js";
+export default {
+    encode(_packet) {
+        const flags = 0;
+        return { flags, bytes: [] };
+    },
+    decode(buffer, flags) {
+        hasEmptyFlags(flags);
+        isEmptyBuf(buffer);
+        return {
+            type: PacketType.pingreq,
+        };
+    },
+};

package/dist/mqttPacket/pingres.js

@@ -0,0 +1,14 @@
+import { PacketType } from "./PacketType.js";
+import { isEmptyBuf } from "./decoder.js";
+export default {
+    encode(_packet) {
+        const flags = 0;
+        return { flags, bytes: [] };
+    },
+    decode(buffer) {
+        isEmptyBuf(buffer);
+        return {
+            type: PacketType.pingres,
+        };
+    },
+};

package/dist/mqttPacket/puback.js

@@ -0,0 +1,20 @@
+import { PacketType } from "./PacketType.js";
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        decoder.done();
+        return {
+            type: PacketType.puback,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/pubcomp.js

@@ -0,0 +1,20 @@
+import { PacketType } from "./PacketType.js";
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        decoder.done();
+        return {
+            type: PacketType.pubcomp,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/publish.js

@@ -0,0 +1,51 @@
+import { PacketType } from "./PacketType.js";
+import { BitMask } from "./BitMask.js";
+import { Encoder, EncoderError } from "./encoder.js";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.js";
+export default {
+    encode(packet) {
+        const qos = packet.qos || 0;
+        const flags = (packet.dup ? BitMask.bit3 : 0) +
+            (qos & 2 ? BitMask.bit2 : 0) +
+            (qos & 1 ? BitMask.bit1 : 0) +
+            (packet.retain ? BitMask.bit0 : 0);
+        const encoder = new Encoder();
+        encoder.setTopic(packet.topic);
+        if (qos === 1 || qos === 2) {
+            if (typeof packet.id !== "number" || packet.id < 1) {
+                throw new EncoderError("when qos is 1 or 2, packet must have id");
+            }
+            encoder.setInt16(packet.id);
+        }
+        encoder.setRemainder(packet.payload);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer, flags) {
+        const dup = booleanFlag(flags, BitMask.bit3);
+        const qos = (flags & 6) >> 1;
+        const retain = booleanFlag(flags, BitMask.bit0);
+        if (qos !== 0 && qos !== 1 && qos !== 2) {
+            throw new DecoderError("Invalid qos");
+        }
+        if (dup && qos === 0) {
+            throw new DecoderError("Invalid qos for possible duplicate");
+        }
+        const decoder = new Decoder(buffer);
+        const topic = decoder.getTopic();
+        let id = 0;
+        if (qos > 0) {
+            id = decoder.getInt16();
+        }
+        const payload = decoder.getRemainder();
+        // no decoder.done() required because of getRemainder
+        return {
+            type: PacketType.publish,
+            topic,
+            payload,
+            dup,
+            retain,
+            qos,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/pubrec.js

@@ -0,0 +1,20 @@
+import { PacketType } from "./PacketType.js";
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        decoder.done();
+        return {
+            type: PacketType.pubrec,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/pubrel.js

@@ -0,0 +1,20 @@
+import { PacketType } from "./PacketType.js";
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        decoder.done();
+        return {
+            type: PacketType.pubrel,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/suback.js

@@ -0,0 +1,29 @@
+import { PacketType } from "./PacketType.js";
+import { Encoder } from "./encoder.js";
+import { Decoder } from "./decoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        encoder.setRemainder(packet.returnCodes);
+        return {
+            flags,
+            bytes: encoder.done(),
+        };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        const payload = decoder.getRemainder();
+        const returnCodes = [];
+        for (const code of payload) {
+            returnCodes.push(code);
+        }
+        return {
+            type: PacketType.suback,
+            id,
+            returnCodes,
+        };
+    },
+};

package/dist/mqttPacket/subscribe.js

@@ -0,0 +1,52 @@
+import { PacketType } from "./PacketType.js";
+import { BitMask } from "./BitMask.js";
+import { Encoder } from "./encoder.js";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.js";
+export default {
+    encode(packet) {
+        // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE Control Packet are reserved and
+        // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
+        // malformed and close the Network Connection [MQTT-3.8.1-1].
+        const flags = 0b0010;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        for (const sub of packet.subscriptions) {
+            encoder.setTopic(sub.topicFilter);
+            encoder.setByte(sub.qos);
+        }
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer, flags) {
+        // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE Control Packet are reserved and
+        // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
+        // malformed and close the Network Connection [MQTT-3.8.1-1].
+        if (!booleanFlag(flags, BitMask.bit1)) {
+            throw new DecoderError("Invalid header");
+        }
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        const subscriptions = [];
+        // The payload of a SUBSCRIBE packet MUST contain at least one Topic Filter / QoS pair.
+        // A SUBSCRIBE packet with no payload is a protocol violation [MQTT-3.8.3-3].
+        do {
+            const topicFilter = decoder.getTopicFilter();
+            const qos = decoder.getByte();
+            if (qos !== 0 && qos !== 1 && qos !== 2) {
+                throw new DecoderError("Invalid qos");
+            }
+            if (qos > 0 && id === 0) {
+                throw new DecoderError("Invalid packet identifier");
+            }
+            subscriptions.push({
+                topicFilter: topicFilter,
+                qos,
+            });
+        } while (!decoder.atEnd());
+        decoder.done();
+        return {
+            type: PacketType.subscribe,
+            id,
+            subscriptions,
+        };
+    },
+};

package/dist/mqttPacket/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mqttPacket/unsuback.js

@@ -0,0 +1,20 @@
+import { PacketType } from "./PacketType.js";
+import { Decoder } from "./decoder.js";
+import { Encoder } from "./encoder.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer) {
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        decoder.done();
+        return {
+            type: PacketType.unsuback,
+            id,
+        };
+    },
+};

package/dist/mqttPacket/unsubscribe.js

@@ -0,0 +1,36 @@
+import { PacketType } from "./PacketType.js";
+import { BitMask } from "./BitMask.js";
+import { Encoder } from "./encoder.js";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.js";
+export default {
+    encode(packet) {
+        // Bits 3,2,1 and 0 of the fixed header of the UNSUBSCRIBE Control Packet are reserved and
+        // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
+        // malformed and close the Network Connection [MQTT-3.10.1-1].
+        const flags = 0b0010;
+        const encoder = new Encoder();
+        encoder.setInt16(packet.id);
+        for (const topicFilter of packet.topicFilters) {
+            encoder.setTopicFilter(topicFilter);
+        }
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer, flags) {
+        if (!booleanFlag(flags, BitMask.bit1)) {
+            throw new DecoderError("Invalid header");
+        }
+        const decoder = new Decoder(buffer);
+        const id = decoder.getInt16();
+        const topicFilters = [];
+        do {
+            const topicFilter = decoder.getTopicFilter();
+            topicFilters.push(topicFilter);
+        } while (!decoder.atEnd());
+        decoder.done();
+        return {
+            type: PacketType.unsubscribe,
+            id,
+            topicFilters,
+        };
+    },
+};

package/dist/mqttPacket/validators.js

@@ -0,0 +1,15 @@
+// deno-lint-ignore no-control-regex
+const invalidUTF8regEx = new RegExp(/\x00|\uFFFD/);
+// deno-lint-ignore no-control-regex
+const invalidTopicRegEx = new RegExp(/^$|\+|#|\x00|\uFFFD/);
+// deno-lint-ignore no-control-regex
+const invalidTopicFilterRegEx = new RegExp(/^$|#.|[^\/]\+|\+[^\/]|\x00|\uFFFD/);
+export function invalidUTF8(value) {
+    return invalidUTF8regEx.test(value);
+}
+export function invalidTopic(value) {
+    return invalidTopicRegEx.test(value);
+}
+export function invalidTopicFilter(value) {
+    return invalidTopicFilterRegEx.test(value);
+}

package/dist/node/client.js

@@ -0,0 +1,65 @@
+// this a NodeJS specific implementation of TCP client sockets
+// it extends the platform agnostic Client class
+import { Client } from "../client/client.js";
+import { logger } from "../client/deps.js";
+import { readFile } from "node:fs/promises";
+import { createConnection } from "node:net";
+import * as tls from "node:tls";
+import { wrapNodeSocket } from "./wrapNodeSocket.js";
+export async function getCaCerts(filename) {
+    if (!filename) {
+        return;
+    }
+    const caCerts = await readFile(filename, { encoding: "utf-8" });
+    if (caCerts === "") {
+        return;
+    }
+    return [caCerts];
+}
+export class TcpClient extends Client {
+    connectMQTT(hostname, port = 1883) {
+        logger.debug({ hostname, port });
+        return new Promise((resolve, reject) => {
+            const socket = createConnection({ port, host: hostname }, () => {
+                logger.debug("Connected to server");
+                resolve(wrapNodeSocket(socket));
+            });
+            socket.once("error", (err) => {
+                // @ts-ignore the type spec of err is missing err.code
+                logger.debug("Connection failed: ", err);
+                reject(err);
+            });
+        });
+    }
+    connectMQTTS(hostname, port = 8883, caCerts) {
+        const opts = {
+            host: hostname,
+            port,
+            secureContext: caCerts
+                ? tls.createSecureContext({ cert: caCerts })
+                : undefined,
+        };
+        logger.debug({ hostname, port, caCerts });
+        return new Promise((resolve, reject) => {
+            const socket = tls.connect(opts, () => {
+                logger.debug("Connected to server");
+                resolve(wrapNodeSocket(socket));
+            });
+            socket.once("error", (err) => {
+                logger.debug("Connection failed", err);
+                reject(err);
+            });
+        });
+    }
+    createConn(protocol, hostname, port, caCerts) {
+        // if you need to support alternative connection types just
+        // overload this method in your subclass
+        if (protocol === "mqtts:") {
+            return this.connectMQTTS(hostname, port, caCerts);
+        }
+        if (protocol === "mqtt:") {
+            return this.connectMQTT(hostname, port);
+        }
+        throw `Unsupported protocol: ${protocol}`;
+    }
+}

package/dist/node/server.js

@@ -0,0 +1,22 @@
+import { createServer } from "node:net";
+import { MqttServer } from "../server/mod.js";
+import { wrapNodeSocket } from "./wrapNodeSocket.js";
+export class TcpServer {
+    mqttServer;
+    server;
+    serverOptions;
+    constructor(serverOptions, mqttOptions) {
+        this.mqttServer = new MqttServer(mqttOptions);
+        this.serverOptions = serverOptions;
+    }
+    start() {
+        this.server = createServer((sock) => this.mqttServer.serve(wrapNodeSocket(sock)));
+        this.server.listen(this.serverOptions.port, this.serverOptions.hostname);
+    }
+    stop() {
+        this.server?.close();
+    }
+    get port() {
+        return this.serverOptions.port;
+    }
+}

package/dist/node/wrapNodeSocket.js

@@ -0,0 +1,47 @@
+import { Writable } from "node:stream";
+function closer(sock) {
+    if (!sock.closed) {
+        sock.end();
+    }
+}
+export function wrapNodeSocket(socket) {
+    const readable = new ReadableStream({
+        type: "bytes",
+        start(controller) {
+            socket.on("data", (data) => {
+                controller.enqueue(data);
+                const desiredSize = controller.desiredSize ?? 0;
+                if (desiredSize <= 0) {
+                    // The internal queue is full, so propagate
+                    // the backpressure signal to the underlying source.
+                    socket.pause();
+                }
+            });
+            socket.on("error", (err) => controller.error(err));
+            socket.on("end", () => {
+                // close the controller
+                controller.close();
+                // and unlock the last BYOB read request
+                controller.byobRequest?.respond(0);
+            });
+        },
+        pull: () => {
+            socket.resume();
+        },
+        cancel: () => {
+            socket.end();
+        },
+    });
+    const writable = Writable.toWeb(socket);
+    const remoteAddr = {
+        hostname: socket.remoteAddress || "",
+        port: socket.remotePort || 0,
+    };
+    const conn = {
+        readable: readable,
+        writable: writable,
+        close: () => closer(socket),
+        remoteAddr,
+    };
+    return conn;
+}

package/dist/persistence/deps.js

@@ -0,0 +1,3 @@
+export { PacketType } from "../mqttPacket/mod.js";
+export { Trie } from "../trie/trie.js";
+export { logger } from "../utils/mod.js";