@seriousme/opifex 1.11.2 → 2.0.3

package/client/handlers/handleSuback.ts

@@ -9,11 +9,14 @@ import type { SubackPacket } from "../deps.ts";
  * - Processes SUBACK packets sent by server to confirm SUBSCRIBE requests
  * - Removes the packet ID from pending outgoing messages
  * - Notifies the client about granted QoS levels for each subscription
+ *    - in V5 the reason codes could carry various errors
  */
 export function handleSuback(ctx: Context, packet: SubackPacket): void {
   const id = packet.id;
   ctx.store.pendingOutgoing.delete(id);
   if (packet.protocolLevel !== 5) {
     ctx.receiveSuback(id, packet.returnCodes);
+    return;
   }
+  ctx.receiveSuback(id, packet.reasonCodes);
 }

package/client/handlers/handleUnsuback.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleUnsuback } from "./handleUnsuback.ts";
+import { PacketType } from "../deps.ts";
+import type { UnsubackPacket } from "../deps.ts";
+
+function createMockContext() {
+  const receivedIds: number[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map(),
+    },
+    receiveUnsuback: (id: number) => {
+      receivedIds.push(id);
+      return true;
+    },
+    receivedIds,
+  };
+}
+
+test("handleUnsuback removes from pending and notifies context", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.unsubscribe, id: 1 });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as UnsubackPacket;
+
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(1),
+    false,
+    "Should remove from pending",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [1],
+    "Should notify context of unsuback",
+  );
+});
+
+test("handleUnsuback handles non-existent packet ID gracefully", () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as UnsubackPacket;
+
+  // Should not throw
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [999],
+    "Should still notify context",
+  );
+});
+
+test("handleUnsuback processes multiple UNSUBACKs correctly", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.unsubscribe, id: 1 });
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.unsubscribe, id: 2 });
+  ctx.store.pendingOutgoing.set(3, { type: PacketType.unsubscribe, id: 3 });
+
+  handleUnsuback(ctx as never, {
+    type: PacketType.unsuback,
+    protocolLevel: 4,
+    id: 2,
+  } as UnsubackPacket);
+
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(1), true);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(2), false);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(3), true);
+  assert.deepStrictEqual(ctx.receivedIds, [2]);
+});
+
+test("handleUnsuback works with MQTT v5", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(5, { type: PacketType.unsubscribe, id: 5 });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 5 as const,
+    id: 5,
+    reasonCodes: [0],
+    properties: {},
+  } as UnsubackPacket;
+
+  handleUnsuback(ctx as never, packet);
+
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(5), false);
+  assert.deepStrictEqual(ctx.receivedIds, [5]);
+});

package/client/mod.ts

@@ -8,8 +8,8 @@ export {
   DEFAULT_PROTOCOLLEVEL,
   DEFAULT_URL,
 } from "./client.ts";
-export { MQTTLevel } from "./deps.ts";
-export type { ProtocolLevel } from "./deps.ts";
+export { MQTTLevel, ReasonCode } from "./deps.ts";
+export type { ProtocolLevel, QoS } from "./deps.ts";
 export type {
   ConnectParameters,
   PublishParameters,

package/client/store/memoryStore.ts

@@ -7,7 +7,7 @@ import type { PacketId } from "./deps.ts";
 
 import {
   type IStore,
-  maxPacketId,
+  MAX_PACKET_ID,
   type PacketStore,
   type PendingAckOutgoing,
   type pendingIncoming,
@@ -50,7 +50,7 @@ export class MemoryStore implements IStore {
     const currentId = this.packetId;
     do {
       this.packetId++;
-      if (this.packetId > maxPacketId) {
+      if (this.packetId > MAX_PACKET_ID) {
         this.packetId = 1;
       }
     } while (

package/client/store/store.ts

@@ -12,7 +12,7 @@ import type {
 /**
  * Maximum value for MQTT packet IDs (65535)
  */
-export const maxPacketId = 0xffff;
+export const MAX_PACKET_ID = 0xffff;
 
 /**
  * Generic type for storing MQTT packets by their packet ID
@@ -65,4 +65,6 @@ export interface IStore {
     void,
     unknown
   >;
+  // generate the next packet ID, wrapping around at MAX_PACKET_ID
+  nextId(): PacketId;
 }

package/deno/README.md

@@ -62,5 +62,4 @@ Opifex is also available on [JSR.io](https://jsr.io/@seriousme/opifex).
 # Platform Native
 
 This folder also contains code to run the server using Deno sockets instead of
-NodeJS sockets. You can modify the import statements in the demoServer/client to
-use these instead.
+NodeJS sockets. It also contains an implementation that uses Websockets

package/deno/tcpClient.test.ts

@@ -0,0 +1,75 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getFileData, TcpClient } from "./tcpClient.ts";
+
+// most client testing is already done in tcpServer.test.ts
+
+test("Deno: Test getFileData - valid file, empty file and undefined", async () => {
+  // 1. Test with a valid file containing data
+  const tempFile = await Deno.makeTempFile({
+    prefix: "test_get_file_data_",
+    suffix: ".txt",
+  });
+  const testContent = "Hello MQTT World!";
+
+  try {
+    await Deno.writeTextFile(tempFile, testContent);
+
+    const result = await getFileData(tempFile);
+    assert.strictEqual(
+      result,
+      testContent,
+      "Should return the correct content of the file",
+    );
+
+    // 2. Test with an empty file
+    const emptyTempFile = await Deno.makeTempFile({
+      prefix: "test_empty_",
+      suffix: ".txt",
+    });
+    try {
+      const emptyResult = await getFileData(emptyTempFile);
+      assert.strictEqual(
+        emptyResult,
+        undefined,
+        "Should return undefined if the file is empty",
+      );
+    } finally {
+      // Clean up the empty temporary file
+      await Deno.remove(emptyTempFile);
+    }
+  } finally {
+    // Clean up the valid temporary file even if assertions fail
+    await Deno.remove(tempFile);
+  }
+
+  // 3. Test with undefined filename
+  const undefinedResult = await getFileData(undefined);
+  assert.strictEqual(
+    undefinedResult,
+    undefined,
+    "Should return undefined immediately if filename is undefined",
+  );
+});
+
+test("Test createConn - unsupported protocol", async () => {
+  const client = new TcpClient();
+
+  // Use an unsupported protocol like 'ftp://' to trigger the throw in createConn
+  const invalidParams = {
+    url: new URL("ftp://localhost:1883"),
+    numberOfRetries: 0,
+  };
+
+  // Assert that connect rejects with the specific "Unsupported protocol" error
+  await assert.rejects(
+    async () => {
+      await client.connect(invalidParams);
+    },
+    {
+      name: "Error",
+      message: "Unsupported protocol: ftp:",
+    },
+    "Should throw an error when an unsupported protocol is provided",
+  );
+});

package/deno/tcpClient.ts

@@ -51,19 +51,24 @@ export class TcpClient extends Client {
     key?: string,
   ): Promise<Deno.TlsConn> {
     logger.debug({ hostname, port, caCerts, cert });
-    return await Deno.connectTls({ hostname, port, caCerts, cert, key });
+    const connectOpts = {
+      hostname,
+      port,
+      ...(caCerts !== undefined && { caCerts }),
+      ...(cert !== undefined && { cert }),
+      ...(key !== undefined && { key }),
+    };
+    return await Deno.connectTls(connectOpts);
   }
 
-  protected override createConn(
-    protocol: string,
-    hostname: string,
-    port?: number,
-    caCerts?: string[],
-    cert?: string,
-    key?: string,
-  ): Promise<SockConn> {
-    // if you need to support alternative connection types just
-    // overload this method in your subclass
+  // overload createConn from the base client class
+  protected override createConn(): Promise<SockConn> {
+    const { protocol, hostname, port: portStr } = this.connectUrl;
+    const port = Number(portStr);
+    const caCerts = this.caCerts;
+    const cert = this.cert;
+    const key = this.key;
+
     if (protocol === "mqtts:") {
       return this.connectMQTTS(hostname, port, caCerts, cert, key);
     }

package/deno/tcpServer.test.ts

@@ -2,15 +2,12 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { TcpClient } from "./tcpClient.ts";
 import { TcpServer } from "./tcpServer.ts";
-import { logger, LogLevel } from "../utils/mod.ts";
-import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import { delay, logger, LogLevel } from "../utils/mod.ts";
+import type { ProtocolLevel, PublishPacket, QoS } from "../mqttPacket/mod.ts";
 
 logger.level(LogLevel.info);
-export function sleep(ms: number): Promise<unknown> {
-  return new Promise((r) => setTimeout(r, ms));
-}
 
-test("Deno Test pubSub using client and server", async function () {
+test("Deno: Test pubSub using client and server", async () => {
   const server = new TcpServer({ port: 0 }, {});
   server.start();
 
@@ -52,17 +49,17 @@ test("Deno Test pubSub using client and server", async function () {
   });
 
   // the IIFE ensures message reception runs in parallel
-  logger.verbose(`Start receiving`);
+  logger.verbose("Start receiving");
   const received: PublishPacket[] = [];
-  (async function () {
+  (async () => {
     for await (const item of client.messages()) {
-      logger.verbose(`Receiving: ${item.topic} -- ${item.qos}`);
+      logger.verbose("Receiving:", item.topic, "--", item.qos);
       received.push(item);
     }
   })();
   // end of IIFE
   for (const item of publishSet) {
-    logger.verbose(`Publishing: ${item.topic} -- ${item.qos}`);
+    logger.verbose("Publishing:", item.topic, "--", item.qos);
     await client.publish({
       topic: item.topic,
       qos: item.qos,
@@ -70,24 +67,24 @@ test("Deno Test pubSub using client and server", async function () {
     });
   }
 
-  await sleep(100);
-  logger.verbose(`Disconnect client`);
+  await delay(100);
+  logger.verbose("Disconnect client");
   await client.disconnect();
 
-  logger.verbose(`Check completeness`);
+  logger.verbose("Check completeness");
   for (const item of publishSet) {
     const found = received.find((f) =>
       f.topic == item.topic && f.qos === item.qos
     );
-    logger.verbose(`Found: ${item.topic} -- ${item.qos}`);
+    logger.verbose("Found:", item.topic, "--", item.qos);
     assert(found, `${item.topic} -- ${item.qos}`);
   }
 
-  logger.verbose(`Stop server`);
+  logger.verbose("Stop server");
   server.stop();
 });
 
-test("Deno Test subscription persistence after reconnect", async function () {
+test("Deno: Test subscription persistence after reconnect", async () => {
   // Start server
   const server = new TcpServer({ port: 0 }, {});
   server.start();
@@ -95,6 +92,10 @@ test("Deno Test subscription persistence after reconnect", async function () {
   const params = {
     url: new URL(`mqtt://${server.address}:${server.port}`),
     numberOfRetries: 0,
+    options: {
+      protocolLevel: 4 as ProtocolLevel,
+      clean: false,
+    },
   };
 
   const client = new TcpClient();
@@ -111,7 +112,7 @@ test("Deno Test subscription persistence after reconnect", async function () {
   });
 
   // Start receiving messages
-  (async function () {
+  (async () => {
     for await (const item of client.messages()) {
       received.push(item);
     }
@@ -119,11 +120,11 @@ test("Deno Test subscription persistence after reconnect", async function () {
 
   // Disconnect client
   await client.disconnect();
-  await sleep(100);
+  await delay(100);
 
   // Reconnect client
   await client.connect(params);
-  await sleep(100);
+  await delay(100);
 
   // Publish test message
   await client.publish({
@@ -132,8 +133,8 @@ test("Deno Test subscription persistence after reconnect", async function () {
     payload: new Uint8Array([0x01]),
   });
 
-  await sleep(100);
-  logger.verbose(`Disconnect client`);
+  await delay(100);
+  logger.verbose("Disconnect client");
   await client.disconnect();
 
   // Verify message was received

package/deno/tcpServer.ts

@@ -27,20 +27,25 @@ export class TcpServer {
     }
   }
   stop() {
+    this.mqttServer.close(true);
     this.listener.close();
   }
 
   get port(): number | undefined {
+    // deno-coverage-ignore-start
     if (this.listener.addr.transport === "tcp") {
       return this.listener.addr.port;
     }
     return undefined;
+    // deno-coverage-ignore-stop
   }
 
   get address(): string | undefined {
+    // deno-coverage-ignore-start
     if (this.listener.addr.transport === "tcp") {
       return this.listener.addr.hostname;
     }
     return undefined;
+    // deno-coverage-ignore-stop
   }
 }

package/deno/tlsServer.test.ts

@@ -0,0 +1,97 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { TcpClient } from "./tcpClient.ts";
+import { TlsServer } from "./tlsServer.ts";
+import { logger, LogLevel } from "../utils/mod.ts";
+import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import { delay, generateLocalhostCerts } from "../dev_utils/mod.ts";
+
+logger.level(LogLevel.info);
+
+const { key, cert, caCert } = generateLocalhostCerts();
+
+test("Deno: Test pubSub using client and server", async () => {
+  const server = new TlsServer(
+    { hostname: "localhost", port: 0, key, cert },
+    {},
+  );
+  server.start();
+
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "server runs a a random port",
+  );
+  logger.verbose("server running on: ", {
+    port: server.port,
+    address: server.address,
+  });
+
+  const params = {
+    url: new URL(`mqtts://localhost:${server.port}`),
+    numberOfRetries: 0,
+    caCerts: [caCert],
+  };
+
+  logger.verbose("client parameters: ", params);
+
+  const client = new TcpClient();
+
+  await client.connect(params);
+  assert(true, "Client connected to server");
+
+  const publishSet: { topic: string; qos: QoS }[] = [
+    { topic: "t0@q0", qos: 0 },
+    { topic: "t1@q0", qos: 0 },
+    { topic: "t2@q0", qos: 0 },
+    { topic: "t0@q1", qos: 1 },
+    { topic: "t1@q1", qos: 1 },
+    { topic: "t2@q1", qos: 1 },
+    { topic: "t0@q2", qos: 2 },
+    { topic: "t1@q2", qos: 2 },
+    { topic: "t2@q2", qos: 2 },
+  ];
+
+  const subscriptions = publishSet.map((item) => ({
+    topicFilter: item.topic,
+    qos: item.qos,
+  }));
+  await client.subscribe({
+    subscriptions,
+  });
+
+  // the IIFE ensures message reception runs in parallel
+  logger.verbose("Start receiving");
+  const received: PublishPacket[] = [];
+  (async () => {
+    for await (const item of client.messages()) {
+      logger.verbose("Receiving:", item.topic, "--", item.qos);
+      received.push(item);
+    }
+  })();
+  // end of IIFE
+  for (const item of publishSet) {
+    logger.verbose("Publishing:", item.topic, "--", item.qos);
+    await client.publish({
+      topic: item.topic,
+      qos: item.qos,
+      payload: new Uint8Array([0x01]),
+    });
+  }
+
+  await delay(100);
+  logger.verbose("Disconnect client");
+  await client.disconnect();
+
+  logger.verbose("Check completeness");
+  for (const item of publishSet) {
+    const found = received.find((f) =>
+      f.topic == item.topic && f.qos === item.qos
+    );
+    logger.verbose("Found:", item.topic, "--", item.qos);
+    assert(found, `${item.topic} -- ${item.qos}`);
+  }
+
+  logger.verbose("Stop server");
+  server.stop();
+});

package/deno/tlsServer.ts

@@ -0,0 +1,42 @@
+/**
+ * This module provides a Deno specific implementation of a TCP socket listener
+ * it uses the platform agnostic MqttServer class
+ *  @module
+ */
+
+import { MqttServer } from "../server/mod.ts";
+import type { MqttServerOptions } from "../server/mod.ts";
+
+/*
+ * TCP server that wraps a MqttServer, see demoServer.ts in the /bin folder
+ */
+export class TlsServer {
+  private listener: Deno.TlsListener;
+  private mqttServer: MqttServer;
+  constructor(
+    serverOptions: Deno.ListenTlsOptions & Deno.TlsCertifiedKeyPem,
+    mqttOptions: MqttServerOptions,
+  ) {
+    this.listener = Deno.listenTls(serverOptions);
+    this.mqttServer = new MqttServer(mqttOptions);
+  }
+
+  async start() {
+    for await (const conn of this.listener) {
+      this.mqttServer.serve(conn);
+    }
+  }
+  stop() {
+    this.mqttServer.close();
+    this.listener.close();
+  }
+  // deno-coverage-ignore-start
+  get port(): number | undefined {
+    return this.listener.addr.port;
+  }
+
+  get address(): string | undefined {
+    return this.listener.addr.hostname;
+  }
+  // deno-coverage-ignore-stop
+}

package/deno/wsServer.test.ts

@@ -0,0 +1,93 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { WsClient } from "../web/wsClient.ts";
+import { WsServer } from "./wsServer.ts";
+import { delay, logger, LogLevel } from "../utils/mod.ts";
+import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
+
+logger.level(LogLevel.info);
+
+test("Deno: Test pubSub using client and server over webSockets", async () => {
+  const server = new WsServer(
+    { hostname: "localhost", port: 0 },
+    {},
+  );
+  server.start();
+
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "Http server runs a a random port",
+  );
+  logger.verbose("server running on: ", {
+    port: server.port,
+    address: server.address,
+  });
+
+  const params = {
+    url: new URL(`ws://localhost:${server.port}`),
+    numberOfRetries: 0,
+  };
+
+  logger.verbose("client parameters: ", params);
+
+  const client = new WsClient();
+  client.onConnected = () => logger.verbose("Client connected to server");
+
+  await client.connect(params);
+
+  const publishSet: { topic: string; qos: QoS }[] = [
+    { topic: "t0@q0", qos: 0 },
+    { topic: "t1@q0", qos: 0 },
+    { topic: "t2@q0", qos: 0 },
+    { topic: "t0@q1", qos: 1 },
+    { topic: "t1@q1", qos: 1 },
+    { topic: "t2@q1", qos: 1 },
+    { topic: "t0@q2", qos: 2 },
+    { topic: "t1@q2", qos: 2 },
+    { topic: "t2@q2", qos: 2 },
+  ];
+
+  const subscriptions = publishSet.map((item) => ({
+    topicFilter: item.topic,
+    qos: item.qos,
+  }));
+  await client.subscribe({
+    subscriptions,
+  });
+
+  // the IIFE ensures message reception runs in parallel
+  logger.verbose("Start receiving");
+  const received: PublishPacket[] = [];
+  (async () => {
+    for await (const item of client.messages()) {
+      logger.verbose("Receiving:", item.topic, "--", item.qos);
+      received.push(item);
+    }
+  })();
+  // end of IIFE
+  for (const item of publishSet) {
+    logger.verbose("Publishing:", item.topic, "--", item.qos);
+    await client.publish({
+      topic: item.topic,
+      qos: item.qos,
+      payload: new Uint8Array([0x01]),
+    });
+  }
+
+  await delay(100);
+  logger.verbose("Disconnect client");
+  await client.disconnect();
+
+  logger.verbose("Check completeness");
+  for (const item of publishSet) {
+    const found = received.find((f) =>
+      f.topic == item.topic && f.qos === item.qos
+    );
+    logger.verbose("Found:", item.topic, "--", item.qos);
+    assert(found, `${item.topic} -- ${item.qos}`);
+  }
+
+  logger.verbose("Stop server");
+  server.stop();
+});