@seriousme/opifex 1.2.1 → 1.3.0

package/dist/client/handlers/handlePacket.js

@@ -0,0 +1,50 @@
+import { ConnectionState } from "../ConnectionState.js";
+import { handleConnack } from "./handleConnack.js";
+import { handlePublish } from "./handlePublish.js";
+import { handlePuback } from "./handlePuback.js";
+import { handlePubrec } from "./handlePubrec.js";
+import { handlePubrel } from "./handlePubrel.js";
+import { handlePubcomp } from "./handlePubcomp.js";
+import { handleSuback } from "./handleSuback.js";
+import { handleUnsuback } from "./handleUnsuback.js";
+import { logger, PacketNameByType, PacketType } from "../deps.js";
+export async function handlePacket(ctx, packet) {
+    logger.debug({ received: JSON.stringify(packet, null, 2) });
+    if (ctx.connectionState !== ConnectionState.connected) {
+        if (packet.type === PacketType.connack) {
+            handleConnack(packet, ctx);
+        }
+        else {
+            throw new Error(`Received ${PacketNameByType[packet.type]} packet before connect`);
+        }
+    }
+    else {
+        switch (packet.type) {
+            case PacketType.pingres:
+                break;
+            case PacketType.publish:
+                await handlePublish(ctx, packet);
+                break;
+            case PacketType.puback:
+                await handlePuback(ctx, packet);
+                break;
+            case PacketType.pubrel:
+                await handlePubrel(ctx, packet);
+                break;
+            case PacketType.pubrec:
+                await handlePubrec(ctx, packet);
+                break;
+            case PacketType.pubcomp:
+                await handlePubcomp(ctx, packet);
+                break;
+            case PacketType.suback:
+                await handleSuback(ctx, packet);
+                break;
+            case PacketType.unsuback:
+                handleUnsuback(ctx, packet);
+                break;
+            default:
+                throw new Error(`Received unexpected ${PacketNameByType[packet.type]} packet after connect`);
+        }
+    }
+}

package/dist/client/handlers/handlePuback.js

@@ -0,0 +1,6 @@
+// A PUBACK Packet is the response to a PUBLISH Packet with QoS level 1.
+export function handlePuback(ctx, packet) {
+    const id = packet.id;
+    ctx.store.pendingOutgoing.delete(id);
+    ctx.receivePuback(id);
+}

package/dist/client/handlers/handlePubcomp.js

@@ -0,0 +1,9 @@
+// The PUBCOMP Packet is the response to a PUBREL Packet.
+// It is the fourth and final packet of the QoS 2 protocol exchange.
+export function handlePubcomp(ctx, packet) {
+    const id = packet.id;
+    if (ctx.store.pendingAckOutgoing.has(id)) {
+        ctx.store.pendingAckOutgoing.delete(id);
+        ctx.receivePuback(id);
+    }
+}

package/dist/client/handlers/handlePublish.js

@@ -0,0 +1,28 @@
+import { PacketType } from "../deps.js";
+// Incoming publish
+export async function handlePublish(ctx, packet) {
+    const qos = packet.qos || 0;
+    if (qos === 0) {
+        ctx.receivePublish(packet);
+        return;
+    }
+    if (packet.id !== undefined) {
+        // qos 1
+        if (qos === 1) {
+            ctx.receivePublish(packet);
+            await ctx.send({
+                type: PacketType.puback,
+                id: packet.id,
+            });
+            return;
+        }
+        // qos 2
+        if (ctx.store) {
+            ctx.store.pendingIncoming.set(packet.id, packet);
+            await ctx.send({
+                type: PacketType.pubrec,
+                id: packet.id,
+            });
+        }
+    }
+}

package/dist/client/handlers/handlePubrec.js

@@ -0,0 +1,17 @@
+import { PacketType } from "../deps.js";
+// A PUBREC Packet is the response to a PUBLISH Packet with QoS 2.
+// It is the second packet of the QoS 2 protocol exchange.
+// Discard message, Store PUBREC received <Packet Identifier>
+// send PUBREL <Packet Identifier>
+export async function handlePubrec(ctx, packet) {
+    const id = packet.id;
+    const ack = {
+        type: PacketType.pubrel,
+        id,
+    };
+    if (ctx.store.pendingOutgoing.has(id)) {
+        ctx.store.pendingAckOutgoing.set(id, ack);
+        ctx.store.pendingOutgoing.delete(id);
+        await ctx.send(ack);
+    }
+}

package/dist/client/handlers/handlePubrel.js

@@ -0,0 +1,19 @@
+import { PacketType } from "../deps.js";
+// A PUBREL Packet is the response to a PUBREC Packet.
+// It is the third packet of the QoS 2 protocol exchange.
+// Method A, Initiate onward delivery of the Application Message then discard message
+// Send PUBCOMP <Packet Identifier>
+export async function handlePubrel(ctx, packet) {
+    const id = packet.id;
+    if (ctx.store.pendingIncoming.has(id)) {
+        const storedPacket = ctx.store.pendingIncoming.get(id);
+        if (storedPacket) {
+            ctx.receivePublish(storedPacket);
+            ctx.store.pendingIncoming.delete(id);
+            await ctx.send({
+                type: PacketType.pubcomp,
+                id,
+            });
+        }
+    }
+}

package/dist/client/handlers/handleSuback.js

@@ -0,0 +1,9 @@
+// A SUBACK Packet is sent by the Server to the Client to confirm receipt
+// and processing of a SUBSCRIBE Packet.
+// A SUBACK Packet contains a list of return codes, that specify the maximum QoS level
+// that was granted in each Subscription that was requested by the SUBSCRIBE.
+export function handleSuback(ctx, packet) {
+    const id = packet.id;
+    ctx.store.pendingOutgoing.delete(id);
+    ctx.receiveSuback(id, packet.returnCodes);
+}

package/dist/client/handlers/handleUnsuback.js

@@ -0,0 +1,7 @@
+// The UNSUBACK Packet is sent by the Server to the Client to confirm receipt
+// of an UNSUBSCRIBE Packet.
+export function handleUnsuback(ctx, packet) {
+    const id = packet.id;
+    ctx.store.pendingOutgoing.delete(id);
+    ctx.receiveUnsuback(id);
+}

package/dist/client/mod.js

@@ -1,3 +1,5 @@
-export { C as Client, D as DEFAULT_URL } from "../client-DqLTBVC2.js";
-import "../timer-DDWVNsyG.js";
-import "node:process";
+/**
+ *  This module provides an MQTT Client interface see the /bin folder for examples
+ *  @module
+ */
+export { Client, DEFAULT_URL } from "./client.js";

package/dist/client/store/deps.js

@@ -0,0 +1 @@
+export { assert } from "../../utils/mod.js";

package/dist/client/store/memoryStore.js

@@ -0,0 +1,36 @@
+import { assert } from "./deps.js";
+import { maxPacketId, } from "./store.js";
+export class MemoryStore {
+    packetId;
+    pendingIncoming;
+    pendingOutgoing;
+    pendingAckOutgoing;
+    constructor() {
+        this.packetId = 0;
+        this.pendingIncoming = new Map();
+        this.pendingOutgoing = new Map();
+        this.pendingAckOutgoing = new Map();
+    }
+    nextId() {
+        const currentId = this.packetId;
+        do {
+            this.packetId++;
+            if (this.packetId > maxPacketId) {
+                this.packetId = 1;
+            }
+        } while ((this.pendingIncoming.has(this.packetId) ||
+            this.pendingOutgoing.has(this.packetId) ||
+            this.pendingAckOutgoing.has(this.packetId)) &&
+            this.packetId !== currentId);
+        assert(this.packetId !== currentId, "No unused packetId available");
+        return this.packetId;
+    }
+    async *pendingOutgoingPackets() {
+        for (const [_id, packet] of this.pendingAckOutgoing) {
+            yield packet;
+        }
+        for (const [_id, packet] of this.pendingOutgoing) {
+            yield packet;
+        }
+    }
+}

package/dist/client/store/store.js

@@ -0,0 +1 @@
+export const maxPacketId = 0xffff;

package/dist/mqttConn/mqttConn.js

@@ -0,0 +1,104 @@
+import { decodePayload, encode, getLengthDecoder, } from "../mqttPacket/mod.js";
+import { assert } from "../utils/mod.js";
+import { Conn } from "../socket/socket.js";
+export const MqttConnError = {
+    invalidPacket: "Invalid Packet",
+    packetTooLarge: "Packet too large",
+    UnexpectedEof: "Unexpected EOF",
+};
+async function readByte(conn) {
+    const buf = new Uint8Array(1);
+    const bytesRead = await conn.read(buf);
+    assert(bytesRead !== null, MqttConnError.UnexpectedEof);
+    assert(bytesRead !== 0, MqttConnError.UnexpectedEof);
+    return buf[0];
+}
+async function readFull(conn, buf) {
+    let bytesRead = 0;
+    while (bytesRead < buf.length) {
+        const read = await conn.read(buf.subarray(bytesRead));
+        assert(read !== null, MqttConnError.UnexpectedEof);
+        assert(read !== 0, MqttConnError.UnexpectedEof);
+        bytesRead += read;
+    }
+}
+/** Read MQTT packet
+ * @throws `Error` if packet is invalid
+ */
+export async function readPacket(conn, maxPacketSize) {
+    // fixed header is 1 byte of type + flags
+    // + a maximum of 4 bytes to encode the remaining length
+    const decodeLength = getLengthDecoder();
+    const firstByte = await readByte(conn);
+    let result;
+    do {
+        const byte = await readByte(conn);
+        result = decodeLength(byte);
+    } while (!result.done);
+    const remainingLength = result.length;
+    assert(remainingLength < maxPacketSize - 1, MqttConnError.packetTooLarge);
+    const packetBuf = new Uint8Array(remainingLength);
+    // read the rest of the packet
+    await readFull(conn, packetBuf);
+    const packet = decodePayload(firstByte, packetBuf);
+    assert(packet !== null, MqttConnError.UnexpectedEof);
+    return packet;
+}
+export class MqttConn {
+    conn;
+    maxPacketSize;
+    _reason = undefined;
+    _isClosed = false;
+    constructor({ conn, maxPacketSize, }) {
+        this.conn = new Conn(conn);
+        this.maxPacketSize = maxPacketSize || 2 * 1024 * 1024;
+    }
+    get reason() {
+        return this._reason;
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this._isClosed) {
+            try {
+                yield await readPacket(this.conn, this.maxPacketSize);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    if (err.name === "PartialReadError") {
+                        err.message = MqttConnError.UnexpectedEof;
+                    }
+                    this._reason = err.message;
+                }
+                // packet too large, malformed packet or connection closed
+                this.close();
+                break;
+            }
+        }
+    }
+    async send(data) {
+        try {
+            await this.conn.write(encode(data));
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                this._reason = err.message;
+            }
+            this.close();
+        }
+    }
+    get isClosed() {
+        return this._isClosed;
+    }
+    close() {
+        if (this.isClosed)
+            return;
+        try {
+            this.conn.close();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this._isClosed = true;
+        }
+    }
+}

package/dist/mqttPacket/AuthenticationResult.js

@@ -0,0 +1,12 @@
+/**
+ *  Possible MQTT authentication results
+ */
+export const AuthenticationResult = {
+    ok: 0,
+    unacceptableProtocol: 1,
+    rejectedUsername: 2,
+    serverUnavailable: 3,
+    badUsernameOrPassword: 4,
+    notAuthorized: 5,
+};
+export const AuthenticationResultByNumber = Object.fromEntries(Object.entries(AuthenticationResult).map(([k, v]) => [v, k]));

package/dist/mqttPacket/BitMask.js

@@ -0,0 +1,10 @@
+export const BitMask = {
+    bit0: 2 ** 0,
+    bit1: 2 ** 1,
+    bit2: 2 ** 2,
+    bit3: 2 ** 3,
+    bit4: 2 ** 4,
+    bit5: 2 ** 5,
+    bit6: 2 ** 6,
+    bit7: 2 ** 7,
+};

package/dist/mqttPacket/PacketType.js

@@ -0,0 +1,18 @@
+export const PacketType = {
+    reserved: 0,
+    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 const PacketNameByType = Object.fromEntries(Object.entries(PacketType).map(([k, v]) => [v, k]));

package/dist/mqttPacket/connack.js

@@ -0,0 +1,27 @@
+import { PacketType } from "./PacketType.js";
+import { BitMask } from "./BitMask.js";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.js";
+import { AuthenticationResultByNumber } from "./AuthenticationResult.js";
+export default {
+    encode(packet) {
+        const flags = 0;
+        return {
+            flags,
+            bytes: [packet.sessionPresent ? 1 : 0, packet.returnCode || 0],
+        };
+    },
+    decode(buffer, _flags) {
+        const decoder = new Decoder(buffer);
+        const sessionPresent = booleanFlag(decoder.getByte(), BitMask.bit0);
+        const returnCode = decoder.getByte();
+        decoder.done();
+        if (!AuthenticationResultByNumber[returnCode]) {
+            throw new DecoderError("Invalid return code");
+        }
+        return {
+            type: PacketType.connack,
+            sessionPresent,
+            returnCode,
+        };
+    },
+};

package/dist/mqttPacket/connect.js

@@ -0,0 +1,115 @@
+import { PacketType } from "./PacketType.js";
+import { BitMask } from "./BitMask.js";
+import { Encoder } from "./encoder.js";
+import { booleanFlag, Decoder, DecoderError, hasEmptyFlags, } from "./decoder.js";
+function invalidProtocolName(version, name) {
+    if (version === 4 && name !== "MQTT") {
+        return true;
+    }
+    return false;
+}
+export default {
+    encode(packet) {
+        const flags = 0;
+        const protocolLevel = 4;
+        const protocolName = protocolLevel === 4 ? "MQTT" : "MQIsdp";
+        const clientId = packet.clientId || "";
+        const usernameFlag = !!packet.username;
+        const passwordFlag = !!packet.password;
+        const willRetain = !!packet.will?.retain;
+        const willQoS = packet.will?.qos || 0;
+        const willFlag = !!packet.will;
+        const cleanSession = packet.clean !== false;
+        const connectFlags = (usernameFlag ? BitMask.bit7 : 0) +
+            (passwordFlag ? BitMask.bit6 : 0) +
+            (willRetain ? BitMask.bit5 : 0) +
+            (willQoS & 2 ? BitMask.bit4 : 0) +
+            (willQoS & 1 ? BitMask.bit3 : 0) +
+            (willFlag ? BitMask.bit2 : 0) +
+            (cleanSession ? BitMask.bit1 : 0);
+        const keepAlive = packet.keepAlive || 0;
+        const encoder = new Encoder();
+        encoder
+            .setUtf8String(protocolName)
+            .setByte(protocolLevel)
+            .setByte(connectFlags)
+            .setInt16(keepAlive)
+            .setUtf8String(clientId);
+        if (packet.will) {
+            encoder.setTopic(packet.will.topic).setByteArray(packet.will.payload);
+        }
+        if (packet.username) {
+            encoder.setUtf8String(packet.username);
+        }
+        if (packet.password) {
+            encoder.setByteArray(packet.password);
+        }
+        return { flags, bytes: encoder.done() };
+    },
+    decode(buffer, flags) {
+        const decoder = new Decoder(buffer);
+        const protocolName = decoder.getUtf8String();
+        const protocolLevel = decoder.getByte();
+        if (invalidProtocolName(protocolLevel, protocolName)) {
+            throw new DecoderError("Invalid protocol name");
+        }
+        const connectFlags = decoder.getByte();
+        const usernameFlag = booleanFlag(connectFlags, BitMask.bit7);
+        const passwordFlag = booleanFlag(connectFlags, BitMask.bit6);
+        const willRetain = booleanFlag(connectFlags, BitMask.bit5);
+        const willQoS = (connectFlags & (BitMask.bit4 + BitMask.bit3)) >> 3;
+        const willFlag = booleanFlag(connectFlags, BitMask.bit2);
+        const cleanSession = booleanFlag(connectFlags, BitMask.bit1);
+        const reservedBit = booleanFlag(connectFlags, BitMask.bit0);
+        hasEmptyFlags(flags);
+        // The Server MUST validate that the reserved flag in the CONNECT Control Packet
+        // is set to zero and disconnect the Client if it is not zero [MQTT-3.1.2-3].
+        if (reservedBit) {
+            throw new DecoderError("Invalid reserved bit");
+        }
+        if (willQoS !== 0 && willQoS !== 1 && willQoS !== 2) {
+            throw new DecoderError("Invalid will qos");
+        }
+        const keepAlive = decoder.getInt16();
+        const clientId = decoder.getUtf8String();
+        let willTopic;
+        let willPayload;
+        if (willFlag) {
+            willTopic = decoder.getTopic();
+            willPayload = decoder.getByteArray();
+        }
+        let username;
+        let password;
+        if (usernameFlag) {
+            username = decoder.getUtf8String();
+        }
+        if (passwordFlag) {
+            password = decoder.getByteArray();
+        }
+        decoder.done();
+        if (!willFlag && (willQoS !== 0 || willRetain === true)) {
+            throw new DecoderError("Will QoS must be 0 and Will retain to false when Will flag is false");
+        }
+        if (clientId.length === 0 && cleanSession === false) {
+            throw new DecoderError("Clean session must be true if clientID is empty");
+        }
+        return {
+            type: PacketType.connect,
+            protocolName: protocolName,
+            protocolLevel,
+            clientId: clientId,
+            username: username ? username : undefined,
+            password: password ? password : undefined,
+            will: willFlag
+                ? {
+                    topic: willTopic || "",
+                    payload: willPayload || Uint8Array.from([0]),
+                    retain: willRetain,
+                    qos: willQoS,
+                }
+                : undefined,
+            clean: cleanSession,
+            keepAlive,
+        };
+    },
+};

package/dist/mqttPacket/decoder.js

@@ -0,0 +1,89 @@
+import { invalidTopic, invalidTopicFilter } from "./validators.js";
+const utf8Decoder = new TextDecoder("utf-8");
+export function booleanFlag(byte, mask) {
+    return !!(byte & mask);
+}
+export function isEmptyBuf(buf) {
+    if (buf.length > 0) {
+        throw new DecoderError("Packet too long");
+    }
+}
+export function hasEmptyFlags(flags) {
+    if (flags !== 0) {
+        throw new DecoderError("Invalid fixed header flags");
+    }
+}
+export class DecoderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DecoderError";
+    }
+}
+export class Decoder {
+    buf;
+    pos;
+    len;
+    constructor(buf, pos = 0) {
+        this.buf = buf;
+        this.pos = pos;
+        this.len = buf.length;
+    }
+    checkpos(pos) {
+        if (pos > this.len) {
+            throw new DecoderError("Packet too short");
+        }
+    }
+    getByte() {
+        this.checkpos(this.pos);
+        return this.buf[this.pos++];
+    }
+    getInt16() {
+        const msb = this.getByte();
+        const lsb = this.getByte();
+        return (msb << 8) | lsb;
+    }
+    getByteArray() {
+        const len = this.getInt16();
+        const start = this.pos;
+        const end = this.pos + len;
+        this.pos = end;
+        this.checkpos(end);
+        return this.buf.subarray(start, end);
+    }
+    getUtf8String() {
+        const str = utf8Decoder.decode(this.getByteArray());
+        return str;
+    }
+    getTopic() {
+        const topic = this.getUtf8String();
+        if (invalidTopic(topic)) {
+            throw new DecoderError("Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards");
+        }
+        return topic;
+    }
+    getTopicFilter() {
+        const topicFilter = this.getUtf8String();
+        if (invalidTopicFilter(topicFilter)) {
+            throw new DecoderError("Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards");
+        }
+        return topicFilter;
+    }
+    getRemainder() {
+        const start = this.pos;
+        const end = this.len;
+        this.pos = end;
+        return this.buf.subarray(start, end);
+    }
+    atEnd() {
+        if (this.len === this.pos) {
+            return true;
+        }
+        return false;
+    }
+    done() {
+        if (this.atEnd()) {
+            return true;
+        }
+        throw new DecoderError("Packet too long");
+    }
+}

package/dist/mqttPacket/disconnect.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, _flags) {
+        isEmptyBuf(buffer);
+        return {
+            type: PacketType.disconnect,
+        };
+    },
+};

package/dist/mqttPacket/encoder.js

@@ -0,0 +1,56 @@
+const utf8Encoder = new TextEncoder();
+import { invalidTopic, invalidTopicFilter } from "./validators.js";
+export class EncoderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EncoderError";
+    }
+}
+export class Encoder {
+    buffer;
+    constructor() {
+        this.buffer = [];
+    }
+    setByte(value) {
+        this.buffer.push(value);
+        return this;
+    }
+    setInt16(value) {
+        this.setByte(value >> 8);
+        this.setByte(value & 0xff);
+        return this;
+    }
+    setByteArray(value) {
+        if (value.length > 0xffff) {
+            throw new EncoderError("More than 0xffff bytes of data");
+        }
+        this.setInt16(value.length);
+        this.buffer.push(...value);
+        return this;
+    }
+    setUtf8String(value) {
+        this.setByteArray(utf8Encoder.encode(value));
+        return this;
+    }
+    setTopic(value) {
+        if (invalidTopic(value)) {
+            throw new EncoderError("Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards");
+        }
+        this.setUtf8String(value);
+        return this;
+    }
+    setTopicFilter(value) {
+        if (invalidTopicFilter(value)) {
+            throw new EncoderError("Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards");
+        }
+        this.setUtf8String(value);
+        return this;
+    }
+    setRemainder(value) {
+        this.buffer.push(...value);
+        return this;
+    }
+    done() {
+        return this.buffer;
+    }
+}