@seriousme/opifex 2.2.0 → 2.3.0

package/node/tcpServer.test.ts

@@ -4,7 +4,9 @@ import { TcpClient } from "./tcpClient.ts";
 import { TcpServer } from "./tcpServer.ts";
 import { logger, LogLevel } from "../utils/mod.ts";
 import { delay } from "../dev_utils/mod.ts";
-import type { ProtocolLevel, PublishPacket, QoS } from "../mqttPacket/mod.ts";
+import type { ProtocolLevel, PublishPacket } from "../mqttPacket/mod.ts";
+import { testClient } from "../dev_utils/testClient.ts";
+import { MqttServer } from "../server/mod.ts";
 
 logger.level(LogLevel.info);
 
@@ -25,64 +27,10 @@ test("Test pubSub using client and server", async () => {
   };
 
   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}`);
-  }
+  await testClient(client, params);
 
   logger.verbose("Stop server");
-  server.stop();
+  await server.stop();
 });
 
 test("Test subscription persistence after reconnect", async () => {
@@ -148,5 +96,11 @@ test("Test subscription persistence after reconnect", async () => {
     "Should receive message on subscribed topic",
   );
 
-  server.stop();
+  await server.stop();
+});
+
+test("Passing a mqttServer works", () => {
+  const mqttServer = new MqttServer({});
+  const server = new TcpServer({ port: 0 }, mqttServer);
+  assert(server.mqttServer === mqttServer);
 });

package/node/tcpServer.ts

@@ -7,7 +7,7 @@ import type { Server } from "node:net";
 import { createServer } from "node:net";
 import type { MqttServerOptions } from "../server/mod.ts";
 import { MqttServer } from "../server/mod.ts";
-import { wrapNodeSocket } from "./wrapNodeSocket.ts";
+import { nodeSocketToNext } from "./nodeSocketToNext.ts";
 
 type ServerOptions = {
   hostname?: string;
@@ -18,16 +18,24 @@ type ServerOptions = {
  * TCP server that wraps a MqttServer, see the /examples folder
  */
 export class TcpServer {
-  private mqttServer: MqttServer;
+  /** the MqttServer instance used by the server */
+  readonly mqttServer: MqttServer;
   private server?: Server;
   private serverOptions;
 
   /**
    * Create a new TCP server
    */
-  constructor(serverOptions: ServerOptions, mqttOptions: MqttServerOptions) {
-    this.mqttServer = new MqttServer(mqttOptions);
+  constructor(
+    serverOptions: ServerOptions,
+    mqttOptions: MqttServerOptions | MqttServer,
+  ) {
     this.serverOptions = serverOptions;
+    if (mqttOptions instanceof MqttServer) {
+      this.mqttServer = mqttOptions;
+    } else {
+      this.mqttServer = new MqttServer(mqttOptions);
+    }
   }
 
   /**
@@ -35,7 +43,7 @@ export class TcpServer {
    */
   async start(): Promise<void> {
     this.server = createServer((sock) =>
-      this.mqttServer.serve(wrapNodeSocket(sock))
+      this.mqttServer.serve(nodeSocketToNext(sock))
     );
     const isListening = new Promise((resolve) => {
       this.server?.on("listening", () => {
@@ -48,10 +56,12 @@ export class TcpServer {
   }
 
   /**
-   * Stop listening
+   * Stop listening, pass {closeMqtt:false} if you do not want the mqttServer to close
    */
-  stop(): void {
-    this.mqttServer.close();
+  async stop(opts = { closeMqtt: true }): Promise<void> {
+    if (opts.closeMqtt) {
+      await this.mqttServer.close();
+    }
     this.server?.close();
   }
 

package/node/tlsServer.test.ts

@@ -3,8 +3,9 @@ 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";
+import { generateLocalhostCerts } from "../dev_utils/mod.ts";
+import { testClient } from "../dev_utils/testClient.ts";
+import { MqttServer } from "../server/mod.ts";
 
 logger.level(LogLevel.info);
 
@@ -33,62 +34,14 @@ test("Test pubSub using client and server", async () => {
   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}`);
-  }
+  await testClient(client, params);
 
   logger.verbose("Stop server");
-  server.stop();
+  await server.stop();
+});
+
+test("Passing a mqttServer works", () => {
+  const mqttServer = new MqttServer({});
+  const server = new TlsServer({ port: 0, key, cert }, mqttServer);
+  assert(server.mqttServer === mqttServer);
 });

package/node/tlsServer.ts

@@ -7,7 +7,7 @@ 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";
+import { nodeSocketToNext } from "./nodeSocketToNext.ts";
 
 type ServerOptions = {
   hostname?: string;
@@ -20,16 +20,24 @@ type ServerOptions = {
  * TLS server that wraps a MqttServer, see the /examples folder
  */
 export class TlsServer {
-  private mqttServer: MqttServer;
+  /** the MqttServer instance used by the server */
+  readonly mqttServer: MqttServer;
   private server?: Server;
   private serverOptions;
 
   /**
    * Create a new TLS server
    */
-  constructor(serverOptions: ServerOptions, mqttOptions: MqttServerOptions) {
-    this.mqttServer = new MqttServer(mqttOptions);
+  constructor(
+    serverOptions: ServerOptions,
+    mqttOptions: MqttServerOptions | MqttServer,
+  ) {
     this.serverOptions = serverOptions;
+    if (mqttOptions instanceof MqttServer) {
+      this.mqttServer = mqttOptions;
+    } else {
+      this.mqttServer = new MqttServer(mqttOptions);
+    }
   }
 
   /**
@@ -44,7 +52,7 @@ export class TlsServer {
 
     this.server = createServer(
       tlsOptions,
-      (sock) => this.mqttServer.serve(wrapNodeSocket(sock)),
+      (sock) => this.mqttServer.serve(nodeSocketToNext(sock)),
     );
     const isListening = new Promise((resolve) => {
       this.server?.on("listening", () => {
@@ -59,8 +67,10 @@ export class TlsServer {
   /**
    * Stop listening
    */
-  stop(): void {
-    this.mqttServer.close();
+  async stop(opts = { closeMqtt: true }): Promise<void> {
+    if (opts.closeMqtt) {
+      await this.mqttServer.close();
+    }
     this.server?.close();
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seriousme/opifex",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "MQTT client & server for Deno & NodeJS and Bun",
   "author": "Hans Klunder",
   "license": "MIT",
@@ -30,7 +30,8 @@
     "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"
+    "bundle": "deno bundle --platform=browser --minify -o examples/public/opifex-wsclient.min.js web/wsClient.ts --sourcemap",
+    "preversion": "npm run bundle && npm run test"
   },
   "files": [
     "package.json",

package/server/context.ts

@@ -10,6 +10,7 @@ import {
 import type {
   AnyPacket,
   ConnectPacket,
+  ConnNext,
   ExtPublishPacket,
   PacketId,
   Persistence,
@@ -18,7 +19,6 @@ import type {
   PubrelPacket,
   ReasonCode,
   ShareName,
-  SockConn,
   Topic,
 } from "./deps.ts";
 
@@ -64,11 +64,11 @@ export type SessionState = typeof SessionState[keyof typeof SessionState];
 export type Handlers = {
   /**
    * Default preconnect handler that unconditionally permits all connections.
-   * @param {SockConn} conn - The connection context.
+   * @param conn - The connection context.
    * @returns {boolean} false will close the connection
    */
   preconnect?(
-    conn: SockConn,
+    conn: ConnNext,
   ): boolean | Promise<boolean>;
 
   /**
@@ -162,7 +162,7 @@ export class Context {
   protocolLevel: ProtocolLevel;
 
   /** The underlying raw socket connection. */
-  conn: SockConn;
+  conn: ConnNext;
 
   /** The wrapped MQTT connection wrapper handling frame reading and writing. */
   mqttConn: MqttConn;
@@ -234,7 +234,7 @@ export class Context {
   constructor(
     configuration: Configuration, // all settings
     persistence: Persistence, // The server persistence layer implementation.
-    conn: SockConn, // The underlying socket connection.
+    conn: ConnNext, // The underlying socket connection.
     handlers: Handlers, // The validation handlers
   ) {
     this.config = configuration;
@@ -676,10 +676,13 @@ export class Context {
       this.sessionEndsTimer.reset();
     }
 
+    const reason = (!this.mqttConn.reason || executewill)
+      ? "normal disconnect"
+      : this.mqttConn.reason;
     logger.info(
       `closing connection from ${
         this.clientId || this.mqttConn.remoteAddress
-      } because of "${this.mqttConn.reason || "normal disconnect"}"`,
+      } because of "${reason}"`,
     );
     if (!this.mqttConn.isClosed) {
       this.mqttConn.close();

package/server/deps.ts

@@ -1,4 +1,4 @@
-export type { SockAddr, SockConn } from "../socket/socket.ts";
+export type { ConnAddr, ConnNext } from "../connNext/connNext.ts";
 export { MqttConn } from "../mqttConn/mqttConn.ts";
 export type {
   ClientSubscription,

package/server/mod.ts

@@ -5,9 +5,9 @@
 export { ReasonCode } from "./deps.ts";
 export type {
   ConnectPacket,
+  ConnNext,
   Persistence,
   ShareName,
-  SockConn,
   Topic,
 } from "./deps.ts";
 export { MqttServer } from "./server.ts";

package/server/server.ts

@@ -1,18 +1,18 @@
 import { logger, MemoryPersistence, ReasonCode } from "./deps.ts";
 import { Context } from "./context.ts";
 import type { Handlers } from "./context.ts";
-import type { Persistence, ShareName, SockConn, Topic } from "./deps.ts";
+import type { ConnNext, Persistence, ShareName, Topic } from "./deps.ts";
 import { handlePacket } from "./handlers/handlePacket.ts";
 import { createConfiguration } from "./config.ts";
 import type { Configuration, ConfigurationInput } from "./config.ts";
 
 /**
  * Default preconnect handler that unconditionally permits all connections.
- * @param {SockConn} _conn - The connection.
- * @returns {boolean} Always returns true
+ * @param  _conn - The connection.
+ * @returns  Always returns true
  */
 const defaultPreconnect = (
-  _conn: SockConn,
+  _conn: ConnNext,
 ) => (true) as const;
 
 /**
@@ -119,10 +119,10 @@ export class MqttServer {
 
   /**
    * Serve a new client connection.
-   * @param {SockConn} conn - The socket connection to serve.
+   * @param conn - The socket connection to serve.
    * @returns {Promise<void>} A promise that resolves when the connection is closed.
    */
-  async serve(conn: SockConn): Promise<void> {
+  async serve(conn: ConnNext): Promise<void> {
     if (this.handlers.preconnect) {
       if (!await this.handlers.preconnect(conn)) {
         conn.close();

package/utils/utils.ts

@@ -3,7 +3,8 @@
  * deserve their own dedicated files.
  */
 
-import { setTimeout as delay } from "node:timers/promises";
-export { delay };
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 export const noop = () => {};

package/web/webSocketToNext.ts

@@ -0,0 +1,183 @@
+import type { ConnAddr, ConnNext } from "../connNext/connNext.ts";
+
+export async function webSocketToNext(
+  ws: WebSocket,
+  remoteAddr?: ConnAddr,
+): Promise<ConnNext> {
+  ws.binaryType = "arraybuffer";
+
+  const messageQueue: Uint8Array[] = [];
+  let queueOffset = 0;
+  const readResolvers: Array<() => void> = [];
+
+  const notifyWaiters = () => {
+    while (readResolvers.length > 0) {
+      const resolve = readResolvers.shift();
+      resolve?.();
+    }
+  };
+
+  // helper to check if websocket is Open
+  const ensureOpen = (): Promise<void> => {
+    if (ws.readyState === WebSocket.OPEN) {
+      return Promise.resolve();
+    }
+    if (ws.readyState >= WebSocket.CLOSING) {
+      return Promise.reject(new Error("WebSocket is closing or closed"));
+    }
+    return new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err: Event) => {
+        cleanup();
+        reject(err);
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("WebSocket closed before opening"));
+      };
+      const cleanup = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        ws.removeEventListener("close", onClose);
+      };
+
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("close", onClose);
+    });
+  };
+
+  ws.addEventListener("message", (event: MessageEvent) => {
+    let chunk: Uint8Array;
+    if (typeof event.data === "string") {
+      chunk = new TextEncoder().encode(event.data);
+    } else if (event.data instanceof ArrayBuffer) {
+      chunk = new Uint8Array(event.data);
+    } else {
+      return;
+    }
+    messageQueue.push(chunk);
+    notifyWaiters();
+  });
+
+  ws.addEventListener("close", notifyWaiters);
+  ws.addEventListener("error", notifyWaiters);
+
+  const getBufferedBytes = (): number => {
+    let total = 0;
+    for (let i = 0; i < messageQueue.length; i++) {
+      total += i === 0
+        ? messageQueue[i]!.byteLength - queueOffset
+        : messageQueue[i]!.byteLength;
+    }
+    return total;
+  };
+
+  const waitForData = (): Promise<void> => {
+    return new Promise<void>((resolve) => {
+      readResolvers.push(resolve);
+    });
+  };
+
+  const connNext = {
+    remoteAddr,
+    localAddr: undefined,
+
+    async read(length?: number): Promise<Uint8Array | null> {
+      try {
+        await ensureOpen();
+      } catch {
+        return null;
+      }
+
+      if (getBufferedBytes() === 0 && ws.readyState >= WebSocket.CLOSING) {
+        return null;
+      }
+
+      while (getBufferedBytes() === 0) {
+        if (ws.readyState >= WebSocket.CLOSING) return null;
+        await waitForData();
+      }
+
+      if (length === undefined) {
+        const firstChunk = messageQueue.shift()!;
+        const result = firstChunk.subarray(queueOffset);
+        queueOffset = 0;
+        return result;
+      }
+
+      while (getBufferedBytes() < length) {
+        if (ws.readyState >= WebSocket.CLOSING) {
+          return null;
+        }
+        await waitForData();
+      }
+
+      const result = new Uint8Array(length);
+      let bytesCopied = 0;
+
+      while (bytesCopied < length && messageQueue.length > 0) {
+        const currentChunk = messageQueue[0]!;
+        const bytesNeeded = length - bytesCopied;
+        const bytesAvailable = currentChunk.byteLength - queueOffset;
+
+        if (bytesAvailable <= bytesNeeded) {
+          result.set(currentChunk.subarray(queueOffset), bytesCopied);
+          bytesCopied += bytesAvailable;
+          messageQueue.shift();
+          queueOffset = 0;
+        } else {
+          result.set(
+            currentChunk.subarray(queueOffset, queueOffset + bytesNeeded),
+            bytesCopied,
+          );
+          bytesCopied += bytesNeeded;
+          queueOffset += bytesNeeded;
+        }
+      }
+
+      return result;
+    },
+
+    async write(data: Uint8Array): Promise<void> {
+      await ensureOpen();
+
+      if (data instanceof Uint8Array) {
+        ws.send(data.buffer as ArrayBuffer);
+      } else {
+        ws.send(data);
+      }
+
+      const HIGH_WATER_MARK = 64 * 1024;
+      while (ws.bufferedAmount > HIGH_WATER_MARK) {
+        if (ws.readyState >= WebSocket.CLOSING) {
+          throw new Error("WebSocket closed while writing");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    },
+
+    close(): void {
+      try {
+        ws.close();
+      } catch {
+        /* swallow */
+      }
+      notifyWaiters();
+    },
+
+    async *[Symbol.asyncIterator]() {
+      while (true) {
+        const chunk = await this.read();
+        if (chunk === null) break;
+        yield chunk;
+      }
+    },
+  };
+
+  await ensureOpen();
+  return connNext;
+}

package/web/wsClient.test.ts

@@ -24,3 +24,25 @@ test("Web: Test createConn - unsupported protocol", async () => {
     "Should throw an error when an unsupported protocol is provided",
   );
 });
+
+test("Web: Test createConn - unsupported host", async () => {
+  const client = new WsClient();
+
+  // Use an host protocol to trigger the ws error
+  const invalidParams = {
+    url: new URL("ws://test.invalid"),
+    numberOfRetries: 0,
+  };
+
+  // Assert that connect rejects with the specific error
+  await assert.rejects(
+    async () => {
+      await client.connect(invalidParams);
+    },
+    {
+      name: "Error",
+      message: /^Failed to connect to WebSocket/,
+    },
+    "Should throw an error when an unreachable host is provided",
+  );
+});