@seriousme/opifex 2.2.0 → 2.4.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.4.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",
@@ -99,7 +100,7 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^26.6.2",
+    "@types/node": "^26.6.5",
     "@types/node-forge": "^1.3.14",
     "node-forge": "^1.4.0"
   }

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,146 @@
+import type { ConnAddr, ConnNext } from "../connNext/connNext.ts";
+import { BaseConnNext } from "../connNext/baseConnNext.ts";
+import { delay } from "../utils/utils.ts";
+
+export class WebSocketConnNext extends BaseConnNext {
+  localAddr = undefined;
+  remoteAddr?: ConnAddr;
+
+  private ws: WebSocket;
+  private messageQueue: Uint8Array[] = [];
+  private maxBufferSize: number;
+  private currentBufferSize = 0;
+  private readResolvers: Array<() => void> = [];
+
+  constructor(
+    ws: WebSocket,
+    remoteAddr?: ConnAddr,
+    maxBufferSize = 1 * 1024 * 1024,
+  ) {
+    super();
+    this.ws = ws;
+    this.remoteAddr = remoteAddr;
+    this.maxBufferSize = maxBufferSize;
+    this.ws.binaryType = "arraybuffer";
+
+    this.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;
+      }
+
+      // Check the bufferlimit (Throttling / Overflow protection)
+      if (this.currentBufferSize + chunk.byteLength > this.maxBufferSize) {
+        this.close();
+        throw new Error(
+          "WebSocket buffer overflow: Too much unread data from push source",
+        );
+      }
+
+      this.messageQueue.push(chunk);
+      this.currentBufferSize += chunk.byteLength;
+      this.notifyWaiters();
+    });
+
+    const onClose = () => {
+      this.closed = true;
+      this.notifyWaiters();
+    };
+    this.ws.addEventListener("close", onClose);
+    this.ws.addEventListener("error", onClose);
+  }
+
+  private notifyWaiters() {
+    while (this.readResolvers.length > 0) {
+      const resolve = this.readResolvers.shift();
+      resolve?.();
+    }
+  }
+
+  private waitForData(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      this.readResolvers.push(resolve);
+    });
+  }
+
+  ensureOpen(): Promise<void> {
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return Promise.resolve();
+    }
+    if (this.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 = () => {
+        this.ws.removeEventListener("open", onOpen);
+        this.ws.removeEventListener("error", onError);
+        this.ws.removeEventListener("close", onClose);
+      };
+
+      this.ws.addEventListener("open", onOpen);
+      this.ws.addEventListener("error", onError);
+      this.ws.addEventListener("close", onClose);
+    });
+  }
+
+  protected async pullNextChunk(): Promise<Uint8Array | null> {
+    if (this.messageQueue.length === 0) {
+      await this.waitForData();
+    }
+    if (this.closed) {
+      return null;
+    }
+    const chunk = this.messageQueue.shift()!;
+    this.currentBufferSize -= chunk.byteLength;
+    return chunk;
+  }
+
+  async write(data: Uint8Array): Promise<void> {
+    if (this.isClosed()) throw new Error("WebSocket is closed");
+    this.ws.send(data.buffer as ArrayBuffer);
+
+    // Check WebSocket bufferedAmount for write-backpressure
+    const HIGH_WATER_MARK = 64 * 1024;
+    while (this.ws.bufferedAmount > HIGH_WATER_MARK) {
+      if (this.isClosed()) throw new Error("WebSocket closed while writing");
+      await delay(10);
+    }
+  }
+
+  close(): void {
+    if (!this.closed) {
+      this.closed = true;
+      try {
+        this.ws.close();
+      } catch {
+        /* swallow */
+      }
+    }
+  }
+}
+
+export async function webSocketToNext(
+  ws: WebSocket,
+  remoteAddr?: ConnAddr,
+  maxBufferSize?: number,
+): Promise<ConnNext> {
+  const connNext = new WebSocketConnNext(ws, remoteAddr, maxBufferSize);
+  await connNext.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",
+  );
+});

package/web/wsClient.ts

@@ -6,8 +6,8 @@
 
 import { Client } from "../client/client.ts";
 import { logger } from "../client/deps.ts";
-import type { SockConn } from "../client/deps.ts";
-import { wrapWebSocket } from "./wrapWebSocket.ts";
+import type { ConnNext, NetAddr } from "../client/deps.ts";
+import { webSocketToNext } from "./webSocketToNext.ts";
 
 /**
  * WsClient extends the Client class to provide WebSocket based clients
@@ -15,22 +15,42 @@ import { wrapWebSocket } from "./wrapWebSocket.ts";
  * see the /examples folder for an example
  */
 export class WsClient extends Client {
-  /** create a websocket and wrap it in a SockConn */
-  private async establishSocket(url: string): Promise<SockConn> {
-    const ws = new WebSocket(url);
-    const conn = await wrapWebSocket(ws);
-    return conn;
+  /** create a websocket and wrap it in a ConnNext */
+  private async establishSocket(
+    url: string,
+    maxBufferSize?: number,
+  ): Promise<ConnNext> {
+    try {
+      const urlObj = new URL(url);
+      const remoteAddr: NetAddr = {
+        transport: "tcp",
+        hostname: urlObj.hostname,
+        port: Number(urlObj.port || 0),
+      };
+      const ws = new WebSocket(url);
+      const connNext = await webSocketToNext(ws, remoteAddr, maxBufferSize);
+      return connNext;
+    } catch (error) {
+      const message = error instanceof ErrorEvent
+        ? ` because of ${error.message}`
+        : "";
+      throw new Error(`Failed to connect to WebSocket at ${url}${message}`);
+    }
   }
 
   /** createConn provides support for both "ws:" and "wss:" URLs */
-  protected override createConn(): Promise<SockConn> {
+  protected override createConn(): Promise<ConnNext> {
     const { protocol, hostname, port: portStr, pathname } = this.connectUrl;
     const port = portStr ? Number(portStr) : (protocol === "wss:" ? 443 : 80);
     const path = pathname || "/mqtt";
+    const maxBufferSize = this.maxBufferSize;
 
     logger.debug({ hostname, port, path });
     if (protocol === "ws:" || protocol === "wss:") {
-      return this.establishSocket(`${protocol}//${hostname}:${port}${path}`);
+      return this.establishSocket(
+        `${protocol}//${hostname}:${port}${path}`,
+        maxBufferSize,
+      );
     }
     throw new Error(`Unsupported protocol: ${protocol}`);
   }