@seriousme/opifex 1.6.3 → 1.7.0

package/dist/node/wrapNodeSocket.js

@@ -1,56 +0,0 @@
-import { Writable } from "node:stream";
-/**
- * Closes a Node.js socket if it is not already closed
- * @param sock - The Node.js socket to close
- */
-function closer(sock) {
-    if (!sock.closed) {
-        sock.end();
-    }
-}
-/**
- * Wraps a Node.js socket into a standard web streams-based socket connection
- * @param socket - The Node.js socket to wrap
- * @returns A socket connection object with readable/writable streams and close method
- */
-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

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

package/dist/persistence/memory/memoryPersistence.js

@@ -1,118 +0,0 @@
-import { Trie, } from "../deps.js";
-import { assert } from "../../utils/mod.js";
-const maxPacketId = 0xffff;
-export class MemoryStore {
-    existingSession = false;
-    clientId;
-    packetId;
-    pendingIncoming;
-    pendingOutgoing;
-    pendingAckOutgoing;
-    subscriptions;
-    constructor(clientId) {
-        this.packetId = 0;
-        this.pendingIncoming = new Map();
-        this.pendingOutgoing = new Map();
-        this.pendingAckOutgoing = new Set();
-        this.subscriptions = new Map();
-        this.clientId = clientId;
-    }
-    nextId() {
-        const currentId = this.packetId;
-        do {
-            this.packetId++;
-            if (this.packetId > maxPacketId) {
-                this.packetId = 0;
-            }
-        } while ((this.pendingOutgoing.has(this.packetId) ||
-            this.pendingAckOutgoing.has(this.packetId)) &&
-            this.packetId !== currentId);
-        assert(this.packetId !== currentId, "No unused packetId available");
-        return this.packetId;
-    }
-}
-export class MemoryPersistence {
-    clientList;
-    retained;
-    trie;
-    constructor() {
-        this.clientList = new Map();
-        this.retained = new Map();
-        this.trie = new Trie(true);
-    }
-    registerClient(clientId, handler, clean) {
-        const existingClient = this.clientList.get(clientId);
-        const store = !clean && existingClient
-            ? existingClient.store
-            : new MemoryStore(clientId);
-        this.clientList.set(clientId, { store, handler });
-        return store;
-    }
-    deregisterClient(clientId) {
-        const client = this.clientList.get(clientId);
-        if (client) {
-            this.unsubscribeAll(client.store);
-            this.clientList.delete(clientId);
-        }
-    }
-    subscribe(store, topicFilter, qos) {
-        const clientId = store.clientId;
-        if (!store.subscriptions.has(topicFilter)) {
-            store.subscriptions.set(topicFilter, qos);
-            this.trie.add(topicFilter, { clientId, qos });
-        }
-    }
-    unsubscribe(store, topicFilter) {
-        const clientId = store.clientId;
-        const qos = store.subscriptions.get(topicFilter);
-        if (qos) {
-            store.subscriptions.delete(topicFilter);
-            this.trie.remove(topicFilter, { clientId, qos });
-        }
-    }
-    unsubscribeAll(store) {
-        for (const [topicFilter, _qos] of store.subscriptions) {
-            this.unsubscribe(store, topicFilter);
-        }
-    }
-    publish(topic, packet) {
-        if (packet.retain) {
-            this.retained.set(packet.topic, packet);
-            if (packet.payload === undefined) {
-                this.retained.delete(packet.topic);
-            }
-        }
-        // dedup clients
-        const clients = new Map();
-        for (const { clientId, qos } of this.trie.match(topic)) {
-            const prevQos = clients.get(clientId);
-            if (!prevQos || prevQos < qos) {
-                clients.set(clientId, qos);
-            }
-        }
-        // publish the message to all clients
-        for (const [clientId, qos] of clients) {
-            const newPacket = Object.assign({}, packet);
-            newPacket.retain = false;
-            newPacket.qos = qos;
-            //  logger.debug(`publish ${topic} to client ${clientId}`);
-            const client = this.clientList.get(clientId);
-            client?.handler(packet);
-        }
-    }
-    handleRetained(clientId) {
-        const retainedTrie = new Trie();
-        const client = this.clientList.get(clientId);
-        const store = client?.store;
-        if (store) {
-            for (const [topicFilter, _qos] of store.subscriptions) {
-                retainedTrie.add(topicFilter, clientId);
-            }
-            for (const [topic, packet] of this.retained) {
-                if (retainedTrie.match(topic).length > 0) {
-                    client?.handler(packet);
-                }
-            }
-        }
-    }
-}

package/dist/persistence/persistence.js

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

package/dist/persistence/store.js

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

package/dist/server/context.js

@@ -1,100 +0,0 @@
-import { logger, MqttConn, PacketNameByType, PacketType, } from "./deps.js";
-export const SysPrefix = "$";
-export const utf8Encoder = new TextEncoder();
-/**
- * The Context class is used to maintain state of a MQTT connection
- * It handles:
- *  - connect/disconnect including broadcasting of these events
- *  - publish
- *  - persistence
- *  - the will
- */
-export class Context {
-    connected;
-    conn;
-    mqttConn;
-    persistence;
-    handlers;
-    static clientList = new Map();
-    store;
-    will;
-    timer;
-    constructor(persistence, conn, handlers) {
-        this.persistence = persistence;
-        this.connected = false;
-        this.conn = conn;
-        this.mqttConn = new MqttConn({ conn });
-        this.handlers = handlers;
-    }
-    async send(packet) {
-        logger.debug("Sending", PacketNameByType[packet.type]);
-        logger.debug(JSON.stringify(packet, null, 2));
-        await this.mqttConn.send(packet);
-    }
-    connect(clientId, clean) {
-        logger.debug("Connecting", clientId);
-        const existingSession = Context.clientList.get(clientId);
-        if (existingSession) {
-            existingSession.close(false);
-        }
-        this.store = this.persistence.registerClient(clientId, this.doPublish.bind(this), clean);
-        this.connected = true;
-        this.broadcast("$SYS/connect/clients", clientId);
-        logger.debug("Connected", clientId);
-    }
-    doPublish(packet) {
-        const qos = packet.qos || 0;
-        if (qos === 0) {
-            packet.id = 0;
-            this.send(packet);
-            return;
-        }
-        if (this.store) {
-            packet.id = this.store.nextId();
-            this.store.pendingOutgoing.set(packet.id, packet);
-            this.send(packet);
-        }
-    }
-    clean(clientId) {
-        this.persistence.deregisterClient(clientId);
-    }
-    close(executewill = true) {
-        if (this.connected) {
-            logger.debug(`Closing ${this.store?.clientId} while mqttConn is ${this.mqttConn.isClosed ? "" : "not "}closed`);
-            this.connected = false;
-            if (typeof this.timer === "object") {
-                this.timer.clear();
-            }
-            if (this.store) {
-                this.broadcast("$SYS/disconnect/clients", this.store.clientId);
-            }
-            if (executewill) {
-                this.handleWill();
-            }
-        }
-        if (!this.mqttConn.isClosed) {
-            this.mqttConn.close();
-        }
-    }
-    handleWill() {
-        if (this.will) {
-            if (!this.will.topic.startsWith(SysPrefix) &&
-                this.handlers.isAuthorizedToPublish &&
-                this.handlers.isAuthorizedToPublish(this, this.will.topic)) {
-                this.persistence.publish(this.will.topic, this.will);
-            }
-        }
-    }
-    broadcast(topic, payload, retain = false) {
-        const packet = {
-            type: PacketType.publish,
-            topic,
-            retain,
-            payload: utf8Encoder.encode(payload),
-        };
-        if (packet.retain === true) {
-            this.persistence.retained.set(packet.topic, packet);
-        }
-        this.persistence.publish(packet.topic, packet);
-    }
-}

package/dist/server/deps.js

@@ -1,5 +0,0 @@
-export { MqttConn } from "../mqttConn/mqttConn.js";
-export { MemoryPersistence } from "../persistence/memory/memoryPersistence.js";
-export { AuthenticationResult, PacketNameByType, PacketType, } from "../mqttPacket/mod.js";
-export { Timer } from "../timer/timer.js";
-export { logger } from "../utils/mod.js";

package/dist/server/handlers/handleConnect.js

@@ -1,80 +0,0 @@
-import { AuthenticationResult, logger, PacketType, Timer, } from "../deps.js";
-/**
- * Checks if the client is authenticated based on the provided credentials
- * @param ctx - The connection context
- * @param packet - The MQTT CONNECT packet
- * @returns Authentication result indicating if the client is authenticated
- */
-function isAuthenticated(ctx, packet) {
-    if (ctx.handlers.isAuthenticated) {
-        return ctx.handlers.isAuthenticated(ctx, packet.clientId || "", packet.username || "", packet.password || new Uint8Array(0));
-    }
-    return AuthenticationResult.ok;
-}
-/**
- * Validates the CONNECT packet
- * @param ctx - The connection context
- * @param packet - The MQTT CONNECT packet to validate
- * @returns Authentication result indicating if the CONNECT packet is valid
- */
-function validateConnect(ctx, packet) {
-    if (packet.protocolLevel !== 4) {
-        return AuthenticationResult.unacceptableProtocol;
-    }
-    return isAuthenticated(ctx, packet);
-}
-/**
- * Processes the validated CONNECT packet
- * @param packet - The MQTT CONNECT packet
- * @param ctx - The connection context
- * @param clientId - The client ID
- */
-function processValidatedConnect(returnCode, packet, ctx, clientId) {
-    if (returnCode === AuthenticationResult.ok) {
-        if (packet.will) {
-            ctx.will = {
-                type: PacketType.publish,
-                qos: packet.will.qos,
-                retain: packet.will.retain,
-                topic: packet.will.topic,
-                payload: packet.will.payload,
-            };
-        }
-        ctx.connect(clientId, packet.clean || false);
-        const keepAlive = packet.keepAlive || 0;
-        if (keepAlive > 0) {
-            logger.debug(`Setting keepalive to ${keepAlive * 1500} ms`);
-            ctx.timer = new Timer(() => {
-                ctx.close();
-            }, Math.floor(keepAlive * 1500));
-        }
-        // is this a new session?
-        // either because its the first time for the client
-        // or it specifically asked for a clean one
-        const previousSession = ctx.store?.existingSession;
-        // client now has a history
-        if (!previousSession && ctx.store) {
-            ctx.store.existingSession = true;
-        }
-        return previousSession || false;
-    }
-    return false;
-}
-/**
- * Handles the MQTT CONNECT packet
- * @param ctx - The connection context
- * @param packet - The MQTT CONNECT packet to handle
- */
-export function handleConnect(ctx, packet) {
-    const clientId = packet.clientId || `Opifex-${crypto.randomUUID()}`;
-    const returnCode = validateConnect(ctx, packet);
-    const sessionPresent = processValidatedConnect(returnCode, packet, ctx, clientId);
-    ctx.send({
-        type: PacketType.connack,
-        sessionPresent,
-        returnCode,
-    });
-    if (returnCode !== AuthenticationResult.ok) {
-        ctx.close();
-    }
-}

package/dist/server/handlers/handleDisconnect.js

@@ -1,9 +0,0 @@
-/**
- * Handles client disconnection by clearing the will message and closing the connection
- * @param {Context} ctx - The connection context object
- * @returns {void}
- */
-export function handleDisconnect(ctx) {
-    ctx.will = undefined;
-    ctx.close();
-}

package/dist/server/handlers/handlePacket.js

@@ -1,65 +0,0 @@
-import { PacketNameByType, PacketType, } from "../deps.js";
-import { handleConnect } from "./handleConnect.js";
-import { handlePingreq } from "./handlePingreq.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 { handleSubscribe } from "./handleSubscribe.js";
-import { handleUnsubscribe } from "./handleUnsubscribe.js";
-import { handleDisconnect } from "./handleDisconnect.js";
-import { logger } from "../deps.js";
-/**
- * Handles incoming MQTT packets based on their type and connection state
- * @param ctx - The connection context containing client state and configuration
- * @param packet - The MQTT packet to handle
- * @throws Error if receiving unexpected packet types or packets before connect
- * @returns Promise that resolves when packet handling is complete
- */
-export async function handlePacket(ctx, packet) {
-    logger.debug("handling", PacketNameByType[packet.type]);
-    logger.debug(JSON.stringify(packet, null, 2));
-    if (!ctx.connected) {
-        if (packet.type === PacketType.connect) {
-            handleConnect(ctx, packet);
-        }
-        else {
-            throw new Error(`Received ${PacketNameByType[packet.type]} packet before connect`);
-        }
-    }
-    else {
-        switch (packet.type) {
-            case PacketType.pingreq:
-                await handlePingreq(ctx);
-                break;
-            case PacketType.publish:
-                await handlePublish(ctx, packet);
-                break;
-            case PacketType.puback:
-                handlePuback(ctx, packet);
-                break;
-            case PacketType.pubrel:
-                await handlePubrel(ctx, packet);
-                break;
-            case PacketType.pubrec:
-                await handlePubrec(ctx, packet);
-                break;
-            case PacketType.pubcomp:
-                handlePubcomp(ctx, packet);
-                break;
-            case PacketType.subscribe:
-                await handleSubscribe(ctx, packet);
-                break;
-            case PacketType.unsubscribe:
-                await handleUnsubscribe(ctx, packet);
-                break;
-            case PacketType.disconnect:
-                handleDisconnect(ctx);
-                break;
-            default:
-                throw new Error(`Received unexpected ${PacketNameByType[packet.type]} packet after connect`);
-        }
-        ctx.timer?.reset();
-    }
-}

package/dist/server/handlers/handlePingreq.js

@@ -1,11 +0,0 @@
-import { PacketType } from "../deps.js";
-/**
- * Handles PINGREQ packet by responding with a PINGRESP packet
- * @param ctx - The connection context containing send method
- * @returns Promise that resolves when PINGRESP is sent
- */
-export async function handlePingreq(ctx) {
-    await ctx.send({
-        type: PacketType.pingres,
-    });
-}

package/dist/server/handlers/handlePuback.js

@@ -1,16 +0,0 @@
-/**
- * Handles PUBACK (Publish Acknowledgment) packets in MQTT protocol
- * @param ctx - The connection context containing the client's state and configuration
- * @param packet - The PUBACK packet received from the client
- * @description
- * PUBACK packets are sent in response to PUBLISH packets with QoS level 1.
- * This function removes the original PUBLISH packet from the pending outgoing messages store
- * once acknowledgment is received.
- */
-export function handlePuback(ctx, packet) {
-    // qos 1 only
-    const id = packet.id;
-    if (ctx.store?.pendingOutgoing.has(id)) {
-        ctx.store.pendingOutgoing.delete(id);
-    }
-}

package/dist/server/handlers/handlePubcomp.js

@@ -1,14 +0,0 @@
-/**
- * Handles PUBCOMP packets which are the response to PUBREL packets in QoS 2 flow
- * @param ctx - The connection context containing the client state and configuration
- * @param packet - The PUBCOMP packet received from the client
- * @description
- * This is the fourth and final packet of the QoS 2 protocol exchange.
- * When received, it removes the message from the pendingAckOutgoing store.
- */
-export function handlePubcomp(ctx, packet) {
-    const id = packet.id;
-    if (ctx.store?.pendingAckOutgoing.has(id)) {
-        ctx.store.pendingAckOutgoing.delete(id);
-    }
-}

package/dist/server/handlers/handlePublish.js

@@ -1,54 +0,0 @@
-import { SysPrefix } from "../context.js";
-import { PacketType } from "../deps.js";
-/**
- * Checks if a client is authorized to publish to a given topic
- * @param ctx - The connection context
- * @param topic - The topic to check authorization for
- * @returns boolean indicating if client is authorized to publish
- */
-function authorizedToPublish(ctx, topic) {
-    if (topic.startsWith(SysPrefix)) {
-        return false;
-    }
-    if (ctx.handlers.isAuthorizedToPublish) {
-        return ctx.handlers.isAuthorizedToPublish(ctx, topic);
-    }
-    return true;
-}
-/**
- * Handles MQTT PUBLISH packets
- * @param ctx - The connection context
- * @param packet - The PUBLISH packet to process
- * @returns Promise that resolves when packet is processed
- * @throws Error if packet processing fails
- */
-export async function handlePublish(ctx, packet) {
-    if (!authorizedToPublish(ctx, packet.topic)) {
-        return;
-    }
-    const qos = packet.qos || 0;
-    if (qos === 0) {
-        ctx.persistence.publish(packet.topic, packet);
-        return;
-    }
-    if (packet.id !== undefined) {
-        // qos 1
-        if (qos === 1) {
-            const id = packet.id; // retain the id
-            ctx.persistence.publish(packet.topic, packet);
-            await ctx.send({
-                type: PacketType.puback,
-                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/server/handlers/handlePubrec.js

@@ -1,23 +0,0 @@
-import { PacketType } from "../deps.js";
-/**
- * Handles PUBREC (QoS 2 Publish Received) packets
- * @param ctx - The connection context
- * @param packet - The PUBREC packet received from the client
- * @returns Promise that resolves when handling is complete
- * @description
- * For QoS 2 message flow:
- * 1. Discards the original publish message
- * 2. Stores that PUBREC was received for the packet ID
- * 3. Sends PUBREL packet in response
- */
-export async function handlePubrec(ctx, packet) {
-    const id = packet.id;
-    if (ctx.store?.pendingOutgoing.has(id)) {
-        ctx.store.pendingOutgoing.delete(id);
-        ctx.store.pendingAckOutgoing.add(id);
-        await ctx.send({
-            type: PacketType.pubrel,
-            id,
-        });
-    }
-}

package/dist/server/handlers/handlePubrel.js

@@ -1,27 +0,0 @@
-import { PacketType } from "../deps.js";
-/**
- * Handles PUBREL (QoS 2 publish release) packets
- *
- * @param ctx - The connection context
- * @param packet - The PUBREL packet received from the client
- * @returns Promise that resolves when handling is complete
- * @description
- * For QoS 2 message delivery:
- * 1. Initiates onward delivery of the Application Message
- * 2. Discards the stored message
- * 3. Sends PUBCOMP packet with the 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.persistence.publish(storedPacket.topic, storedPacket);
-            ctx.store.pendingIncoming.delete(id);
-            await ctx.send({
-                type: PacketType.pubcomp,
-                id,
-            });
-        }
-    }
-}

package/dist/server/handlers/handleSubscribe.js

@@ -1,56 +0,0 @@
-import { PacketType, } from "../deps.js";
-/**
- * @constant {number} SubscriptionFailure
- * @description Code indicating a failed subscription attempt
- */
-const SubscriptionFailure = 0x80;
-/**
- * Checks if a client is authorized to subscribe to a topic
- * @param  ctx - The connection context
- * @param  topicFilter - The topic filter to check authorization for
- * @returns True if authorized, false otherwise
- */
-function authorizedToSubscribe(ctx, topicFilter) {
-    if (ctx.handlers.isAuthorizedToSubscribe) {
-        return ctx.handlers.isAuthorizedToSubscribe(ctx, topicFilter);
-    }
-    return true;
-}
-/**
- * @function handleSubscribe
- * @description Processes an MQTT SUBSCRIBE packet
- * @param {Context} ctx - The connection context
- * @param {SubscribePacket} packet - The SUBSCRIBE packet received from the client
- * @returns {Promise<void>}
- * @throws {Error} If subscription processing fails
- * @remarks The order of return codes in the SUBACK Packet MUST match the order of Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1]
- */
-export async function handleSubscribe(ctx, packet) {
-    /*
-     * The order of return codes in the SUBACK Packet MUST match the order of
-     * Topic Filters in the SUBSCRIBE Packet [MQTT-3.9.3-1].
-     */
-    const validSubscriptions = [];
-    const returnCodes = packet.subscriptions.map((sub) => {
-        if (ctx.store) {
-            if (!authorizedToSubscribe(ctx, sub.topicFilter)) {
-                return SubscriptionFailure;
-            }
-            ctx.persistence.subscribe(ctx.store, sub.topicFilter, sub.qos);
-            validSubscriptions.push(sub);
-            return sub.qos;
-        }
-        return SubscriptionFailure;
-    });
-    await ctx.send({
-        type: PacketType.suback,
-        id: packet.id,
-        returnCodes: returnCodes,
-    });
-    /*
-     * send any retained messages that match these subscriptions
-     */
-    if (ctx.store) {
-        ctx.persistence.handleRetained(ctx.store.clientId);
-    }
-}

package/dist/server/handlers/handleUnsubscribe.js

@@ -1,18 +0,0 @@
-import { PacketType } from "../deps.js";
-/**
- * Handles MQTT unsubscribe packets by removing subscriptions and sending acknowledgement
- * @param ctx - The connection context containing client information and methods
- * @param packet - The MQTT unsubscribe packet containing topics to unsubscribe from
- * @returns Promise that resolves when unsubscribe is complete and acknowledged
- */
-export async function handleUnsubscribe(ctx, packet) {
-    for (const topic of packet.topicFilters) {
-        if (ctx.store) {
-            ctx.persistence.unsubscribe(ctx.store, topic);
-        }
-    }
-    await ctx.send({
-        type: PacketType.unsuback,
-        id: packet.id,
-    });
-}