@seriousme/opifex 1.1.0

package/mqttPacket/unsubscribe.test.ts

@@ -0,0 +1,136 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Unsubscribe", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.unsubscribe,
+      id: 1,
+      topicFilters: ["a/b", "c/d"],
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0xa2, // packetType + flags
+      12, // remainingLength
+      // variableHeader
+      0, // id MSB
+      1, // id LSB
+      // payload
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      97, // 'a'
+      47, // '/'
+      98, // 'b'
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      99, // 'c'
+      47, // '/'
+      100, // 'd'
+    ]),
+  );
+});
+
+test("decode Unsubscribe", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0xa2, // packetType + flags
+        12, // remainingLength
+        // variableHeader
+        0, // id MSB
+        1, // id LSB
+        // payload
+        0, // topic filter length MSB
+        3, // topic filter length LSB
+        97, // 'a'
+        47, // '/'
+        98, // 'b'
+        0, // topic filter length MSB
+        3, // topic filter length LSB
+        99, // 'c'
+        47, // '/'
+        100, // 'd'
+      ]),
+    ),
+    {
+      type: PacketType.unsubscribe,
+      id: 1,
+      topicFilters: ["a/b", "c/d"],
+    },
+  );
+});
+
+test("decode Unsubscribe missing bit 1 flag", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0xa0, // packetType + flags
+          12, // remainingLength
+          // variableHeader
+          0, // id MSB
+          1, // id LSB
+          // payload
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          99, // 'c'
+          47, // '/'
+          100, // 'd'
+        ]),
+      ),
+    Error,
+    "Invalid header",
+  );
+});
+
+test("decode unsubscribe packet too short", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0xa2, // packetType + flags
+          10, // remainingLength
+          // variableHeader
+          0, // id MSB
+          1, // id LSB
+          // payload
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          99, // 'c'
+        ]),
+      ),
+    Error,
+    "too short",
+  );
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0xa2, // packetType + flags
+          14, // remainingLength
+          // variableHeader
+          0, // id MSB
+          1, // id LSB
+        ]),
+      ),
+    Error,
+    "too short",
+  );
+});

package/mqttPacket/unsubscribe.ts

@@ -0,0 +1,48 @@
+import type { PacketId, Topic, TopicFilter, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { BitMask } from "./BitMask.ts";
+import { Encoder } from "./encoder.ts";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
+
+export type UnsubscribePacket = {
+  type: TPacketType;
+  id: PacketId;
+  topicFilters: TopicFilter[];
+};
+
+export default {
+  encode(packet: UnsubscribePacket) {
+    // Bits 3,2,1 and 0 of the fixed header of the UNSUBSCRIBE Control Packet are reserved and
+    // MUST be set to 0,0,1 and 0 respectively. The Server MUST treat any other value as
+    // malformed and close the Network Connection [MQTT-3.10.1-1].
+    const flags = 0b0010;
+
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    for (const topicFilter of packet.topicFilters) {
+      encoder.setTopicFilter(topicFilter);
+    }
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array, flags: number): UnsubscribePacket {
+    if (!booleanFlag(flags, BitMask.bit1)) {
+      throw new DecoderError("Invalid header");
+    }
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+
+    const topicFilters: Topic[] = [];
+    do {
+      const topicFilter = decoder.getTopicFilter();
+      topicFilters.push(topicFilter);
+    } while (!decoder.atEnd());
+    decoder.done();
+
+    return {
+      type: PacketType.unsubscribe,
+      id,
+      topicFilters,
+    };
+  },
+};

package/mqttPacket/validators.ts

@@ -0,0 +1,20 @@
+import type { Topic, TopicFilter } from "./types.ts";
+
+// deno-lint-ignore no-control-regex
+const invalidUTF8regEx = new RegExp(/\x00|\uFFFD/);
+// deno-lint-ignore no-control-regex
+const invalidTopicRegEx = new RegExp(/^$|\+|#|\x00|\uFFFD/);
+// deno-lint-ignore no-control-regex
+const invalidTopicFilterRegEx = new RegExp(/^$|#.|[^\/]\+|\+[^\/]|\x00|\uFFFD/);
+
+export function invalidUTF8(value: string): boolean {
+  return invalidUTF8regEx.test(value);
+}
+
+export function invalidTopic(value: Topic): boolean {
+  return invalidTopicRegEx.test(value);
+}
+
+export function invalidTopicFilter(value: TopicFilter): boolean {
+  return invalidTopicFilterRegEx.test(value);
+}

package/node/README.md

@@ -0,0 +1,46 @@
+# Running Opifex server/client on NodeJS
+
+These instructions specifify how to run [Opifex](README.md) on NodeJS. To run
+Opifex on Deno see the [instructions](../deno/README.md)
+
+## Playing around
+
+Make sure you have NodeJS with a version > 22.6.0 installed.
+
+### Server
+
+```bash
+npx -p @seriousme/opifex demoserver --help
+```
+
+### Client
+
+```bash
+npx @seriousme/opifex mqtt --help
+```
+
+## Local deployment
+
+You can use:
+
+```bash
+npm install @seriousme/opifex
+```
+
+to install Opifex.
+
+Or clone the repository, e.g. using:
+
+```bash
+git clone https://github.com/seriousme/opifex.git
+```
+
+and then use:
+
+```bash
+./bin/demoServer.ts --help
+```
+
+```bash
+./bin/mqtt.ts --help
+```

package/node/client.ts

@@ -0,0 +1,58 @@
+import { Client } from "../client/client.ts";
+import { logger } from "../client/deps.ts";
+import { readFile } from "node:fs/promises";
+import { connect } from "node:net";
+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) {
+  if (!filename) {
+    return;
+  }
+  const caCerts = await readFile(filename, { encoding: "utf-8" });
+  if (caCerts === "") {
+    return;
+  }
+  return [caCerts];
+}
+
+export class TcpClient extends Client {
+  protected async connectMQTT(hostname: string, port = 1883) {
+    logger.debug({ hostname, port });
+    return wrapNodeSocket(await connect({ host: hostname, port }));
+  }
+
+  protected async connectMQTTS(
+    hostname: string,
+    port = 8883,
+    caCerts?: string[],
+  ) {
+    const opts = {
+      host: hostname,
+      port,
+      secureContext: caCerts
+        ? tls.createSecureContext({ cert: caCerts })
+        : undefined,
+    };
+    logger.debug({ hostname, port, caCerts });
+    return wrapNodeSocket(await tls.connect(opts));
+  }
+
+  protected override createConn(
+    protocol: string,
+    hostname: string,
+    port?: number,
+    caCerts?: string[],
+  ): Promise<SockConn> {
+    // if you need to support alternative connection types just
+    // overload this method in your subclass
+    if (protocol === "mqtts:") {
+      return this.connectMQTTS(hostname, port, caCerts);
+    }
+    if (protocol === "mqtt:") {
+      return this.connectMQTT(hostname, port);
+    }
+    throw `Unsupported protocol: ${protocol}`;
+  }
+}

package/node/server.test.ts

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { TcpServer } from "./server.ts";
+
+test("testServer", () => {
+  const server = new TcpServer({ port: 0 }, {});
+  server.start();
+  assert.deepStrictEqual(
+    server.port !== undefined,
+    true,
+    "server runs a a random port",
+  );
+  server.stop();
+});

package/node/server.ts

@@ -0,0 +1,34 @@
+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";
+
+type ServerOptions = {
+  hostname?: string;
+  port?: number;
+};
+
+export class TcpServer {
+  private mqttServer: MqttServer;
+  private server?: Server;
+  private serverOptions;
+  constructor(serverOptions: ServerOptions, mqttOptions: MqttServerOptions) {
+    this.mqttServer = new MqttServer(mqttOptions);
+    this.serverOptions = serverOptions;
+  }
+
+  start() {
+    this.server = createServer((sock) =>
+      this.mqttServer.serve(wrapNodeSocket(sock))
+    );
+    this.server.listen(this.serverOptions.port, this.serverOptions.hostname);
+  }
+  stop() {
+    this.server?.close();
+  }
+
+  get port() {
+    return this.serverOptions.port;
+  }
+}

package/node/wrapNodeSocket.ts

@@ -0,0 +1,54 @@
+import type { Socket } from "node:net";
+import { Writable } from "node:stream";
+import type { SockConn } from "../socket/socket.ts";
+
+function closer(sock: Socket) {
+  if (!sock.closed) {
+    sock.end();
+  }
+}
+
+export function wrapNodeSocket(socket: Socket): SockConn {
+  const readable = new ReadableStream(
+    {
+      type: "bytes",
+      start(controller) {
+        socket.on("data", (data: ArrayBufferView) => {
+          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", () => {
+          // unlock the last BYOB read request
+          controller.byobRequest?.respond(1);
+          // and close the controller
+          controller.close();
+        });
+      },
+      pull: () => {
+        socket.resume();
+      },
+      cancel: () => {
+        socket.end();
+      },
+    },
+  );
+  const writable = Writable.toWeb(socket);
+  const remoteAddr = {
+    hostname: socket.remoteAddress || "",
+    port: socket.remotePort || 0,
+  };
+
+  const conn: SockConn = {
+    readable: readable as ReadableStream<Uint8Array>,
+    writable: writable as WritableStream<Uint8Array>,
+    closer: () => closer(socket),
+    remoteAddr,
+  };
+  return conn;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@seriousme/opifex",
+  "version": "1.1.0",
+  "description": "MQTT client & server for Deno & NodeJS",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --experimental-strip-types --test --test-skip-pattern='/^Deno/'"
+  },
+  "keywords": [
+    "MQTT",
+    "typescript",
+    "mqtt-broker"
+  ],
+  "bin": {
+    "mqtt": "bin/mqtt.ts",
+    "demoServer": "bin/demoServer.ts"
+  },
+  "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",
+  "engines": {
+    "node": ">=22.6.0"
+  },
+  "dependencies": {
+    "@types/node": "^22.8.6"
+  }
+}

package/persistence/deps.ts

@@ -0,0 +1,12 @@
+export type {
+  ClientId,
+  PacketId,
+  PublishPacket,
+  QoS,
+  Subscription,
+  Topic,
+  TopicFilter,
+} from "../mqttPacket/mod.ts";
+export { PacketType } from "../mqttPacket/mod.ts";
+export { Trie } from "../trie/trie.ts";
+export { logger } from "../utils/mod.ts";

package/persistence/memory/memoryPersistence.test.ts

@@ -0,0 +1,151 @@
+import {
+  MemoryPersistence as Persistence,
+  MemoryStore as Store,
+} from "./memoryPersistence.ts";
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { PacketType, type PublishPacket } from "../deps.ts";
+
+const payloadAny = new TextEncoder().encode("any");
+const qos = 1;
+
+function delay(ms: number): Promise<unknown> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+test("new should create new Persistence object", () => {
+  const persistence = new Persistence();
+  assert.deepStrictEqual(typeof persistence, "object");
+  assert.deepStrictEqual(persistence instanceof Persistence, true);
+});
+
+test(
+  "Registring a client should register the client and return a Store Object",
+  () => {
+    const persistence = new Persistence();
+    const clientId = "myClient";
+    const client = persistence.registerClient(clientId, () => {}, false);
+    assert.deepStrictEqual(persistence.clientList.has(clientId), true);
+    assert.deepStrictEqual(typeof client, "object");
+    assert.deepStrictEqual(client instanceof Store, true);
+  },
+);
+
+test("pub/sub should work", async () => {
+  const persistence = new Persistence();
+  const clientId = "myClient";
+  const topic = "/myTopic";
+  const publishPacket: PublishPacket = {
+    type: PacketType.publish,
+    id: 1,
+    topic,
+    payload: payloadAny,
+  };
+
+  function makePacket(id: number | undefined) {
+    publishPacket.id = id;
+    return publishPacket;
+  }
+  const seen = new Set();
+
+  function handler(packet: PublishPacket): void {
+    seen.add(packet.id);
+  }
+
+  const store = persistence.registerClient(clientId, handler, false);
+
+  persistence.subscribe(store, topic, qos);
+  assert.deepStrictEqual(
+    store.subscriptions.has(topic),
+    true,
+    "topic is registered as subscription",
+  );
+  persistence.publish(topic, makePacket(25));
+  persistence.publish(topic, makePacket(27));
+  persistence.publish(topic, makePacket(undefined));
+  persistence.publish("noTopic", makePacket(undefined));
+  await delay(10);
+  assert.deepStrictEqual(seen.size, 3, `received ${seen.size} messages`);
+});
+
+test("many packets should work", async () => {
+  const persistence = new Persistence();
+  const clientId = "myClient";
+  const topic = "/myTopic";
+  const numMessages = 1000;
+  const publishPacket: PublishPacket = {
+    type: PacketType.publish,
+    id: 1,
+    topic,
+    payload: payloadAny,
+  };
+
+  function makePacket(id: number | undefined) {
+    const newPacket = Object.assign({}, publishPacket);
+    newPacket.id = id;
+    return newPacket;
+  }
+  const seen = new Set();
+
+  function handler(packet: PublishPacket): void {
+    assert.deepStrictEqual(
+      seen.has(packet.id),
+      false,
+      `Not seen ${packet.id} before`,
+    );
+    seen.add(packet.id);
+  }
+
+  const store = persistence.registerClient(clientId, handler, false);
+
+  persistence.subscribe(store, topic, qos);
+  assert.deepStrictEqual(
+    store.subscriptions.has(topic),
+    true,
+    "topic is registered as subscription",
+  );
+  for (let i = 0; i < numMessages; i++) {
+    persistence.publish(topic, makePacket(i));
+  }
+  await delay(10);
+  assert.deepStrictEqual(
+    seen.size,
+    numMessages,
+    `received all ${numMessages} messages`,
+  );
+});
+
+test("unsubscribe should work", () => {
+  const persistence = new Persistence();
+  const clientId = "myClient";
+  const topic = "/myTopic";
+  const publishPacket: PublishPacket = {
+    type: PacketType.publish,
+    id: 1,
+    topic,
+    payload: payloadAny,
+  };
+
+  const seen = new Set();
+  function handler(packet: PublishPacket): void {
+    assert.deepStrictEqual(
+      seen.has(packet.id),
+      false,
+      `Not seen ${packet.id} before`,
+    );
+    seen.add(packet.id);
+  }
+
+  const store = persistence.registerClient(clientId, handler, false);
+  persistence.subscribe(store, topic, qos);
+  persistence.unsubscribe(store, topic);
+
+  assert.deepStrictEqual(
+    store.subscriptions.has(topic),
+    false,
+    "topic is still registered as subscription after unsubscription",
+  );
+  persistence.publish(topic, publishPacket);
+  assert.deepStrictEqual(seen.size, 0);
+});