@seriousme/opifex 1.4.0 → 1.5.1

package/CHANGELOG.md

@@ -4,6 +4,24 @@
 
 ### Changed
 
+## [v1.5.1] 16-01-2025
+
+### Changed
+
+- fixed issue with QoS=1
+
+## [v1.5.0] 02-01-2025
+
+### Changed
+
+- added client certificate support to mqtts.ts
+
+## [v1.4.0] 02-01-2025
+
+### Changed
+
+- added client certificate support (w0otness)
+
 ## [v1.3.0] 19-11-2024
 
 ### Changed

package/bin/mqtt.ts

@@ -2,7 +2,8 @@
 import { DEFAULT_URL } from "../client/mod.ts";
 import { logger, LogLevel } from "../utils/mod.ts";
 import { getArgs, parseArgs } from "../utils/mod.ts";
-import { getCaCerts, TcpClient } from "../node/client.ts";
+import { getFileData, TcpClient } from "../node/client.ts";
+import type { Args } from "../utils/args.ts";
 
 const client = new TcpClient();
 const encoder = new TextEncoder();
@@ -21,18 +22,30 @@ const ConnectHelp = `
   -i/--clientId   the clientId to connect to the server
   -U/--username   the username to connect to the server
   -P/--password   the password to connect to the server
-  -c/--certFile   the path to a certFile
+  -C/--caFile     the path to a CA certificate file
+  -c/--certFile   the path to a certificate file
+  -k/--keyFile    the path to a key file
   -n/--noClean    try to resume a previous session
   -h/--help       this text
   `;
 
 const connectOpts = {
-  string: ["url", "username", "password", "certFile", "clientId"],
+  string: [
+    "url",
+    "username",
+    "password",
+    "caFile",
+    "certFile",
+    "keyFile",
+    "clientId",
+  ],
   alias: {
     u: "url",
     U: "username",
     P: "password",
+    C: "caFile",
     c: "certFile",
+    k: "keyFile",
     i: "clientId",
     n: "noClean",
     h: "help",
@@ -80,9 +93,25 @@ function parseQos(qosArg: string | number) {
   return 0;
 }
 
+async function getTLSdata(connectArgs: Args) {
+  const caFileData = await getFileData(connectArgs.caFile);
+  const caCerts = caFileData ? [caFileData] : undefined;
+  const cert = await getFileData(connectArgs.certFile);
+  const key = await getFileData(connectArgs.keyFile);
+  return {
+    caCerts,
+    cert,
+    key,
+  };
+}
+
 async function subscribe() {
   const connectArgs = parseArgs(getArgs(), connectOpts);
-  const caCerts = await getCaCerts(connectArgs.certFile);
+  const {
+    caCerts,
+    cert,
+    key,
+  } = await getTLSdata(connectArgs);
   const subscribeArgs = parseArgs(getArgs(), subscribeOpts);
   if (connectArgs.help) {
     console.log(SubscribeHelp);
@@ -96,6 +125,8 @@ async function subscribe() {
     await client.connect({
       url: connectArgs.url,
       caCerts,
+      cert,
+      key,
       options: {
         username: connectArgs.username,
         password: encoder.encode(connectArgs.password),
@@ -157,7 +188,11 @@ const publishOpts = {
 
 async function publish() {
   const connectArgs = parseArgs(getArgs(), connectOpts);
-  const caCerts = await getCaCerts(connectArgs.certFile);
+  const {
+    caCerts,
+    cert,
+    key,
+  } = await getTLSdata(connectArgs);
   const publishArgs = parseArgs(getArgs(), publishOpts);
   if (connectArgs.help) {
     console.log(PublishHelp);
@@ -171,6 +206,8 @@ async function publish() {
     await client.connect({
       url: connectArgs.url,
       caCerts,
+      cert,
+      key,
       options: {
         username: connectArgs.username,
         password: encoder.encode(connectArgs.password),

package/client/client.ts

@@ -173,19 +173,23 @@ export class Client {
       type: PacketType.publish,
       ...params,
     };
-    await this.ctx.send(packet);
+    await this.ctx.publish(packet);
   }
 
   async subscribe(params: SubscribeParameters): Promise<void> {
     const packet: SubscribePacket = {
       type: PacketType.subscribe,
-      id: this.ctx.store.nextId(),
+      id: 0, //placeholder
       ...params,
     };
-    await this.ctx.send(packet);
+    await this.ctx.subscribe(packet);
   }
 
   async *messages(): AsyncGenerator<PublishPacket, void, unknown> {
     yield* this.ctx.incoming;
   }
+
+  closeMessages(reason?: string) {
+    this.ctx.incoming.close(reason);
+  }
 }

package/client/handlers/handlePacket.ts

@@ -25,7 +25,7 @@ export async function handlePacket(
   ctx: Context,
   packet: AnyPacket,
 ): Promise<void> {
-  logger.debug({ received: JSON.stringify(packet, null, 2) });
+  logger.debug({ received: PacketNameByType[packet.type], packet });
   if (ctx.connectionState !== ConnectionState.connected) {
     if (packet.type === PacketType.connack) {
       handleConnack(packet as ConnackPacket, ctx);

package/deno/client.ts

@@ -4,15 +4,15 @@ import { Client } from "../client/client.ts";
 import { logger } from "../client/deps.ts";
 import type { SockConn } from "../client/deps.ts";
 
-export async function getCaCerts(filename: string | undefined) {
+export async function getFileData(filename: string | undefined) {
   if (!filename) {
     return;
   }
-  const caCerts = await Deno.readTextFile(filename);
-  if (caCerts === "") {
+  const data = await Deno.readTextFile(filename);
+  if (data === "") {
     return;
   }
-  return [caCerts];
+  return data;
 }
 
 export class TcpClient extends Client {

package/deno/server.ts

@@ -29,4 +29,11 @@ export class TcpServer {
     }
     return undefined;
   }
+
+  get address() {
+    if (this.listener.addr.transport === "tcp") {
+      return this.listener.addr.hostname;
+    }
+    return undefined;
+  }
 }

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@seriousme/opifex",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "exports": {
     "./server": "./server/mod.ts",
     "./client": "./client/mod.ts"

package/dist/bin/mqtt.js

@@ -2,7 +2,7 @@
 import { DEFAULT_URL } from "../client/mod.js";
 import { logger, LogLevel } from "../utils/mod.js";
 import { getArgs, parseArgs } from "../utils/mod.js";
-import { getCaCerts, TcpClient } from "../node/client.js";
+import { getFileData, TcpClient } from "../node/client.js";
 const client = new TcpClient();
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -18,17 +18,29 @@ const ConnectHelp = `
   -i/--clientId   the clientId to connect to the server
   -U/--username   the username to connect to the server
   -P/--password   the password to connect to the server
-  -c/--certFile   the path to a certFile
+  -C/--caFile     the path to a CA certificate file
+  -c/--certFile   the path to a certificate file
+  -k/--keyFile    the path to a key file
   -n/--noClean    try to resume a previous session
   -h/--help       this text
   `;
 const connectOpts = {
-    string: ["url", "username", "password", "certFile", "clientId"],
+    string: [
+        "url",
+        "username",
+        "password",
+        "caFile",
+        "certFile",
+        "keyFile",
+        "clientId",
+    ],
     alias: {
         u: "url",
         U: "username",
         P: "password",
+        C: "caFile",
         c: "certFile",
+        k: "keyFile",
         i: "clientId",
         n: "noClean",
         h: "help",
@@ -72,9 +84,20 @@ function parseQos(qosArg) {
     console.log("QoS must be between 0 and 2");
     return 0;
 }
+async function getTLSdata(connectArgs) {
+    const caFileData = await getFileData(connectArgs.caFile);
+    const caCerts = caFileData ? [caFileData] : undefined;
+    const cert = await getFileData(connectArgs.certFile);
+    const key = await getFileData(connectArgs.keyFile);
+    return {
+        caCerts,
+        cert,
+        key,
+    };
+}
 async function subscribe() {
     const connectArgs = parseArgs(getArgs(), connectOpts);
-    const caCerts = await getCaCerts(connectArgs.certFile);
+    const { caCerts, cert, key, } = await getTLSdata(connectArgs);
     const subscribeArgs = parseArgs(getArgs(), subscribeOpts);
     if (connectArgs.help) {
         console.log(SubscribeHelp);
@@ -88,6 +111,8 @@ async function subscribe() {
         await client.connect({
             url: connectArgs.url,
             caCerts,
+            cert,
+            key,
             options: {
                 username: connectArgs.username,
                 password: encoder.encode(connectArgs.password),
@@ -145,7 +170,7 @@ const publishOpts = {
 };
 async function publish() {
     const connectArgs = parseArgs(getArgs(), connectOpts);
-    const caCerts = await getCaCerts(connectArgs.certFile);
+    const { caCerts, cert, key, } = await getTLSdata(connectArgs);
     const publishArgs = parseArgs(getArgs(), publishOpts);
     if (connectArgs.help) {
         console.log(PublishHelp);
@@ -159,6 +184,8 @@ async function publish() {
         await client.connect({
             url: connectArgs.url,
             caCerts,
+            cert,
+            key,
             options: {
                 username: connectArgs.username,
                 password: encoder.encode(connectArgs.password),

package/dist/client/client.js

@@ -113,17 +113,20 @@ export class Client {
             type: PacketType.publish,
             ...params,
         };
-        await this.ctx.send(packet);
+        await this.ctx.publish(packet);
     }
     async subscribe(params) {
         const packet = {
             type: PacketType.subscribe,
-            id: this.ctx.store.nextId(),
+            id: 0, //placeholder
             ...params,
         };
-        await this.ctx.send(packet);
+        await this.ctx.subscribe(packet);
     }
     async *messages() {
         yield* this.ctx.incoming;
     }
+    closeMessages(reason) {
+        this.ctx.incoming.close(reason);
+    }
 }

package/dist/client/handlers/handlePacket.js

@@ -9,7 +9,7 @@ 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) });
+    logger.debug({ received: PacketNameByType[packet.type], packet });
     if (ctx.connectionState !== ConnectionState.connected) {
         if (packet.type === PacketType.connack) {
             handleConnack(packet, ctx);

package/dist/node/client.js

@@ -6,15 +6,15 @@ 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) {
+export async function getFileData(filename) {
     if (!filename) {
         return;
     }
-    const caCerts = await readFile(filename, { encoding: "utf-8" });
-    if (caCerts === "") {
+    const data = await readFile(filename, { encoding: "utf-8" });
+    if (data === "") {
         return;
     }
-    return [caCerts];
+    return data;
 }
 export class TcpClient extends Client {
     connectMQTT(hostname, port = 1883) {
@@ -30,15 +30,15 @@ export class TcpClient extends Client {
             });
         });
     }
-    connectMQTTS(hostname, port = 8883, caCerts) {
+    connectMQTTS(hostname, port = 8883, ca, cert, key) {
         const opts = {
             host: hostname,
             port,
-            secureContext: caCerts
-                ? tls.createSecureContext({ cert: caCerts })
+            secureContext: (ca || key || cert)
+                ? tls.createSecureContext({ ca, cert, key })
                 : undefined,
         };
-        logger.debug({ hostname, port, caCerts });
+        logger.debug({ hostname, port, ca, cert });
         return new Promise((resolve, reject) => {
             const socket = tls.connect(opts, () => {
                 logger.debug("Connected to server");

package/dist/node/server.js

@@ -17,6 +17,24 @@ export class TcpServer {
         this.server?.close();
     }
     get port() {
-        return this.serverOptions.port;
+        const address = this.server?.address();
+        if (typeof address === "object") {
+            return address?.port;
+        }
+        return this.serverOptions?.port;
+    }
+    get address() {
+        const addressResult = this.server?.address();
+        if (typeof addressResult === "object") {
+            const address = addressResult?.address;
+            if (address === "::") {
+                return "localhost";
+            }
+            if (address?.includes(":")) {
+                return `[${address}]`;
+            }
+            return address;
+        }
+        return addressResult;
     }
 }

package/dist/server/handlers/handlePublish.js

@@ -21,10 +21,11 @@ export async function handlePublish(ctx, packet) {
     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: packet.id,
+                id,
             });
             return;
         }

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/conformanceServer.ts","../bin/demoServer.ts","../bin/mqtt.ts"],"version":"5.7.2"}
+{"root":["../bin/conformanceServer.ts","../bin/demoServer.ts","../bin/mqtt.ts"],"version":"5.7.3"}

package/node/client.ts

@@ -8,15 +8,15 @@ import * as tls from "node:tls";
 import type { SockConn } from "../socket/socket.ts";
 import { wrapNodeSocket } from "./wrapNodeSocket.ts";
 
-export async function getCaCerts(filename: string | undefined) {
+export async function getFileData(filename: string | undefined) {
   if (!filename) {
     return;
   }
-  const caCerts = await readFile(filename, { encoding: "utf-8" });
-  if (caCerts === "") {
+  const data = await readFile(filename, { encoding: "utf-8" });
+  if (data === "") {
     return;
   }
-  return [caCerts];
+  return data;
 }
 
 export class TcpClient extends Client {
@@ -40,16 +40,18 @@ export class TcpClient extends Client {
   protected connectMQTTS(
     hostname: string,
     port = 8883,
-    caCerts?: string[],
+    ca?: string[],
+    cert?: string,
+    key?: string,
   ): Promise<SockConn> {
     const opts = {
       host: hostname,
       port,
-      secureContext: caCerts
-        ? tls.createSecureContext({ cert: caCerts })
+      secureContext: (ca || key || cert)
+        ? tls.createSecureContext({ ca, cert, key })
         : undefined,
     };
-    logger.debug({ hostname, port, caCerts });
+    logger.debug({ hostname, port, ca, cert });
     return new Promise((resolve, reject) => {
       const socket = tls.connect(opts, () => {
         logger.debug("Connected to server");

package/node/server.test.ts

@@ -1,14 +1,94 @@
-import assert from "node:assert/strict";
 import { test } from "node:test";
+import assert from "node:assert/strict";
+import { TcpClient } from "./client.ts";
 import { TcpServer } from "./server.ts";
+import { logger, LogLevel } from "../utils/mod.ts";
+import type { PublishPacket, QoS } from "../mqttPacket/mod.ts";
 
-test("testServer", () => {
+logger.level(LogLevel.info);
+export function sleep(ms: number): Promise<unknown> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export async function serverTest() {
   const server = new TcpServer({ port: 0 }, {});
   server.start();
+  await sleep(1000);
+
   assert.deepStrictEqual(
     server.port !== undefined,
     true,
     "server runs a a random port",
   );
+  logger.verbose({ port: server.port, address: server.address });
+
+  const params = {
+    url: new URL(`mqtt://${server.address}:${server.port}`),
+    numberOfRetries: 0,
+  };
+
+  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 function () {
+    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 sleep(100);
+  logger.verbose(`Disconnect client`);
+  //client.closeMessages();
+  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();
+}
+
+test("Test pubSub using client and server", async function () {
+  await serverTest();
+  logger.verbose("End of test");
 });

package/node/server.ts

@@ -31,6 +31,25 @@ export class TcpServer {
   }
 
   get port() {
-    return this.serverOptions.port;
+    const address = this.server?.address();
+    if (typeof address === "object") {
+      return address?.port;
+    }
+    return this.serverOptions?.port;
+  }
+
+  get address() {
+    const addressResult = this.server?.address();
+    if (typeof addressResult === "object") {
+      const address = addressResult?.address;
+      if (address === "::") {
+        return "localhost";
+      }
+      if (address?.includes(":")) {
+        return `[${address}]`;
+      }
+      return address;
+    }
+    return addressResult;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seriousme/opifex",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "MQTT client & server for Deno & NodeJS",
   "type": "module",
   "scripts": {

package/server/handlers/handlePublish.ts

@@ -28,10 +28,11 @@ export async function handlePublish(
   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: packet.id,
+        id,
       });
       return;
     }