@seriousme/opifex 1.11.2 → 2.0.3

package/node/tcpServer.test.ts

@@ -3,14 +3,12 @@ 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 } from "../dev_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("Test pubSub using client and server", async function () {
+test("Test pubSub using client and server", async () => {
   const server = new TcpServer({ port: 0 }, {});
   server.start();
 
@@ -52,17 +50,17 @@ test("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 +68,24 @@ test("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("Test subscription persistence after reconnect", async function () {
+test("Test subscription persistence after reconnect", async () => {
   // Start server
   const server = new TcpServer({ port: 0 }, {});
   server.start();
@@ -95,8 +93,14 @@ test("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,
+    },
   };
 
+  logger.verbose("client parameters: ", params);
+
   const client = new TcpClient();
   const testTopic = "test/topic";
   const received: PublishPacket[] = [];
@@ -111,7 +115,7 @@ test("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 +123,11 @@ test("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 +136,8 @@ test("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/node/tcpServer.ts

@@ -40,21 +40,26 @@ export class TcpServer {
     return;
   }
   stop() {
+    this.mqttServer.close();
     this.server?.close();
   }
 
   get port() {
     const address = this.server?.address();
+    // deno-coverage-ignore-start
     if (typeof address === "object" && address !== null) {
       return address?.port;
     }
     return this.serverOptions?.port;
+    // deno-coverage-ignore-stop
   }
 
   get address() {
     const addressResult = this.server?.address();
+    // deno-coverage-ignore-start
     if (typeof addressResult === "object") {
       const address = addressResult?.address;
+
       if (address === "::") {
         return "localhost";
       }
@@ -65,4 +70,5 @@ export class TcpServer {
     }
     return addressResult;
   }
+  // deno-coverage-ignore-stop
 }

package/node/tlsServer.test.ts

@@ -0,0 +1,94 @@
+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("Test pubSub using client and server", async () => {
+  const server = new TlsServer({ 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://${server.address}:${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/node/tlsServer.ts

@@ -0,0 +1,81 @@
+/*
+ * This module provides a NodeJS specific implementation of a tls socket listener
+ * it uses the platform agnostic MqttServer class
+ *  @module
+ */
+import type { Server } from "node:net";
+import { createServer } from "node:tls";
+import type { MqttServerOptions } from "../server/mod.ts";
+import { MqttServer } from "../server/mod.ts";
+import { wrapNodeSocket } from "./wrapNodeSocket.ts";
+
+type ServerOptions = {
+  hostname?: string;
+  port?: number;
+  key: string;
+  cert: string;
+};
+
+/*
+ * TCP server that wraps a MqttServer, see demoServer.ts in the /bin folder
+ */
+export class TlsServer {
+  private mqttServer: MqttServer;
+  private server?: Server;
+  private serverOptions;
+
+  constructor(serverOptions: ServerOptions, mqttOptions: MqttServerOptions) {
+    this.mqttServer = new MqttServer(mqttOptions);
+    this.serverOptions = serverOptions;
+  }
+
+  async start() {
+    const tlsOptions = {
+      minVersion: "TLSv1.3" as const,
+      key: this.serverOptions.key,
+      cert: this.serverOptions.cert,
+    };
+
+    this.server = createServer(
+      tlsOptions,
+      (sock) => this.mqttServer.serve(wrapNodeSocket(sock)),
+    );
+    const isListening = new Promise((resolve) => {
+      this.server?.on("listening", () => {
+        resolve(true);
+      });
+    });
+    this.server.listen(this.serverOptions.port, this.serverOptions.hostname);
+    await isListening;
+    return;
+  }
+  stop() {
+    this.mqttServer.close();
+    this.server?.close();
+  }
+
+  get port() {
+    const address = this.server?.address();
+    if (typeof address === "object" && address !== null) {
+      return address?.port;
+    }
+    return this.serverOptions?.port;
+  }
+
+  get address() {
+    const addressResult = this.server?.address();
+    // deno-coverage-ignore-start
+    if (typeof addressResult === "object") {
+      const address = addressResult?.address;
+      if (address === "::") {
+        return "localhost";
+      }
+      if (address?.includes(":")) {
+        return `[${address}]`;
+      }
+      return address;
+    }
+    return addressResult;
+  }
+  // deno-coverage-ignore-stop
+}

package/node/wrapNodeSocket.ts

@@ -2,7 +2,7 @@
  * Utility functions for wrapping Node.js sockets into standard web streams.
  */
 import type { Socket } from "node:net";
-import { Writable } from "node:stream";
+import { Readable, Writable } from "node:stream";
 import type { NetAddr, SockConn } from "../socket/socket.ts";
 
 /**
@@ -10,9 +10,11 @@ import type { NetAddr, SockConn } from "../socket/socket.ts";
  * @param sock - The Node.js socket to close
  */
 function closer(sock: Socket): void {
+  // deno-coverage-ignore-start
   if (!sock.closed) {
     sock.end();
   }
+  // deno-coverage-ignore-stop
 }
 
 /**
@@ -21,41 +23,16 @@ function closer(sock: Socket): void {
  * @returns A socket connection object with readable/writable streams and close method
  */
 export function wrapNodeSocket(socket: Socket): SockConn {
-  const readable = new ReadableStream(
-    {
-      type: "bytes",
-      start(controller) {
-        socket.on("data", (data: Uint8Array<ArrayBuffer>) => {
-          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: unknown) => 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 readable = Readable.toWeb(socket);
   const writable = Writable.toWeb(socket);
+
+  // deno-coverage-ignore-start
   const remoteAddr: NetAddr = {
     hostname: socket.remoteAddress || "",
     port: socket.remotePort || 0,
     transport: "tcp",
   };
+  // deno-coverage-ignore-stop
 
   const conn: SockConn = {
     readable: readable as ReadableStream<Uint8Array>,

package/package.json

@@ -1,25 +1,37 @@
 {
   "name": "@seriousme/opifex",
-  "version": "1.11.2",
-  "description": "MQTT client & server for Deno & NodeJS",
-  "type": "module",
-  "scripts": {
-    "test": "node --experimental-strip-types --test --test-skip-pattern='/^Deno/'",
-    "prebuild": "rm -rf dist",
-    "build": "npx -p typescript tsc --build",
-    "format": "deno fmt",
-    "preversion": "npm run test",
-    "version": "jq '( { name:.name , version:.version, license:.license } + .deno)' package.json > deno.json && deno install && git add deno.json"
+  "version": "2.0.3",
+  "description": "MQTT client & server for Deno & NodeJS and Bun",
+  "author": "Hans Klunder",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seriousme/opifex.git"
   },
+  "bugs": {
+    "url": "https://github.com/seriousme/opifex/issues"
+  },
+  "homepage": "https://github.com/seriousme/opifex#readme",
   "keywords": [
     "MQTT",
     "typescript",
     "mqtt-broker"
   ],
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
   "bin": {
     "mqtt": "dist/bin/mqtt.js",
     "demoServer": "dist/bin/demoServer.js"
   },
+  "scripts": {
+    "test": "node  --test --test-skip-pattern='^(?:Deno|Web):'",
+    "build": "rm -rf dist && npx -p typescript tsc --build",
+    "format": "deno fmt",
+    "coverage": "deno test -A . --coverage --clean --coverage-raw-data-only && deno coverage --exclude=.config --exclude=dev_utils --html",
+    "preversion": "npm run test"
+  },
   "files": [
     "package.json",
     "README.md",
@@ -31,43 +43,59 @@
     "dist/**/*.d.ts.map"
   ],
   "exports": {
-    "./tcpClient": "./dist/node/tcpClient.js",
-    "./tcpServer": "./dist/node/tcpServer.js",
-    "./server": "./dist/server/mod.js",
-    "./client": "./dist/client/mod.js",
-    "./trie": "./dist/trie/trie.js",
-    "./persistence": "./dist/persistence/mod.js",
-    "./mqttConn": "./dist/mqttConn/mqttConn.js",
-    "./mqttPacket": "./dist/mqttPacket/mod.js",
-    "./utils": "./dist/utils/mod.js"
-  },
-  "deno": {
-    "exports": {
-      "./tcpClient": "./deno/tcpClient.ts",
-      "./tcpServer": "./deno/tcpServer.ts",
-      "./server": "./server/mod.ts",
-      "./client": "./client/mod.ts",
-      "./trie": "./trie/trie.ts",
-      "./persistence": "./persistence/mod.ts",
-      "./mqttConn": "./mqttConn/mqttConn.ts",
-      "./mqttPacket": "./mqttPacket/mod.ts",
-      "./utils": "./utils/mod.ts"
+    "./tcpClient": {
+      "deno": "./deno/tcpClient.ts",
+      "default": "./dist/node/tcpClient.js"
     },
-    "exclude": [
-      "dist"
-    ]
-  },
-  "author": "Hans Klunder",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/seriousme/opifex.git"
-  },
-  "bugs": {
-    "url": "https://github.com/seriousme/opifex/issues"
+    "./wsClient": {
+      "deno": "./web/wsClient.ts",
+      "browser": "./dist/web/wsClient.js",
+      "default": null
+    },
+    "./tcpServer": {
+      "deno": "./deno/tcpServer.ts",
+      "default": "./dist/node/tcpServer.js"
+    },
+    "./tlsServer": {
+      "deno": "./deno/tlsServer.ts",
+      "default": "./dist/node/tlsServer.js"
+    },
+    "./wsServer": {
+      "deno": "./deno/wsServer.ts",
+      "default": null
+    },
+    "./server": {
+      "deno": "./server/mod.ts",
+      "default": "./dist/server/mod.js"
+    },
+    "./client": {
+      "deno": "./client/mod.ts",
+      "default": "./dist/client/mod.js"
+    },
+    "./trie": {
+      "deno": "./trie/trie.ts",
+      "default": "./dist/trie/trie.js"
+    },
+    "./persistence": {
+      "deno": "./persistence/mod.ts",
+      "default": "./dist/persistence/mod.js"
+    },
+    "./mqttConn": {
+      "deno": "./mqttConn/mqttConn.ts",
+      "default": "./dist/mqttConn/mqttConn.js"
+    },
+    "./mqttPacket": {
+      "deno": "./mqttPacket/mod.ts",
+      "default": "./dist/mqttPacket/mod.js"
+    },
+    "./utils": {
+      "deno": "./utils/mod.ts",
+      "default": "./dist/utils/mod.js"
+    }
   },
-  "homepage": "https://github.com/seriousme/opifex#readme",
   "devDependencies": {
-    "@types/node": "^24.6.2"
+    "@types/node": "^26.6.2",
+    "@types/node-forge": "^1.3.14",
+    "node-forge": "^1.4.0"
   }
 }