@seriousme/opifex 1.2.1 → 1.3.0

package/dist/trie/trie.js

@@ -0,0 +1,95 @@
+export class Trie {
+    #value;
+    #children;
+    separator = "/";
+    wildcardOne = "+";
+    wildcardSubtree = "#";
+    reservedPrefix = "$";
+    looseCompare;
+    constructor(looseCompare = false) {
+        this.#value = [];
+        this.#children = new Map();
+        this.looseCompare = looseCompare;
+    }
+    matchChild(child, parts) {
+        const childNode = this.#children.get(child);
+        return childNode ? childNode._match(parts) : [];
+    }
+    match(key) {
+        const parts = key.split(this.separator);
+        // toplevel wildcards are not allowed to match toplevel reserved topics
+        if (parts.length > 0 && parts[0].charAt(0) === this.reservedPrefix) {
+            return this._matchPrefix(parts);
+        }
+        return this._match(parts);
+    }
+    _matchPrefix(parts) {
+        if (parts.length === 0) {
+            return this.#value ? this.#value : [];
+        }
+        const [first, ...rest] = parts;
+        return this.matchChild(first, rest);
+    }
+    _match(parts) {
+        if (parts.length === 0) {
+            return this.#value ? this.#value : [];
+        }
+        const [first, ...rest] = parts;
+        const exact = this.matchChild(first, rest);
+        const single = this.matchChild(this.wildcardOne, rest);
+        const subtree = this.matchChild(this.wildcardSubtree, []);
+        const results = exact.concat(single, subtree);
+        return results;
+    }
+    add(key, value) {
+        return this._add(key.split(this.separator), value);
+    }
+    _add(parts, value) {
+        if (parts.length === 0) {
+            this.#value = this.#value.concat(value);
+            return;
+        }
+        const [first, ...rest] = parts;
+        const child = this.#children.get(first);
+        if (child instanceof Trie) {
+            child._add(rest, value);
+        }
+        else {
+            const node = new Trie(this.looseCompare);
+            this.#children.set(first, node);
+            node._add(rest, value);
+        }
+        return;
+    }
+    remove(key, value) {
+        return this._remove(key.split(this.separator), value);
+    }
+    _remove(parts, value) {
+        if (parts.length === 0) {
+            const arr = this.#value || [];
+            this.#value = arr.filter(this.filter(value));
+            return;
+        }
+        const [first, ...rest] = parts;
+        const node = this.#children.get(first);
+        if (node) {
+            node._remove(rest, value);
+            if (node.#value.length === 0 && this.#children.size === 0) {
+                this.#children.delete(first);
+            }
+        }
+    }
+    filter(value) {
+        if (this.looseCompare && typeof value === "object") {
+            return (item) => {
+                for (const key in value) {
+                    if (value[key] !== item[key]) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+        }
+        return (item) => item !== value;
+    }
+}

package/dist/tsconfig.tsbuildinfo

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

package/dist/utils/args.js

@@ -0,0 +1,61 @@
+function formatValue(key, value, boolean, string) {
+    if (key === "__proto__" || key === "constructor") {
+        throw new Error(`Invalid argument: ${key}`);
+    }
+    if (boolean.includes(key)) {
+        if (value !== "false") {
+            return true;
+        }
+        return false;
+    }
+    if (!string.includes(key)) {
+        const num = Number(value);
+        if (!Number.isNaN(num)) {
+            return num;
+        }
+    }
+    return value;
+}
+function parseKeyValue(arg, alias) {
+    if (arg.startsWith("--no-")) {
+        const key = arg.slice(5);
+        return [key, false];
+    }
+    if (arg.startsWith("--")) {
+        const [key, value] = arg.slice(2).split("=", 2);
+        return [key, value];
+    }
+    if (arg.startsWith("-")) {
+        const [flag, value] = arg.slice(1).split("=", 2);
+        const key = alias[flag] || flag;
+        return [key, value];
+    }
+    return ["_", arg];
+}
+export function parseArgs(args, opts = {}) {
+    const { alias = {}, boolean = [], string = [], default: defaults = {} } = opts;
+    const result = { ...defaults };
+    result["_"] = [];
+    for (let i = 0; i < args.length; i++) {
+        const [key, value] = parseKeyValue(args[i], alias);
+        if (key === "_") {
+            result["_"].push(formatValue(key, value, boolean, string));
+            continue;
+        }
+        if (value === undefined) {
+            const nextArg = args[i + 1];
+            if (nextArg !== undefined &&
+                !nextArg.startsWith("-") &&
+                !boolean.includes(key)) {
+                result[key] = formatValue(key, nextArg, boolean, string);
+                i++;
+            }
+            else {
+                result[key] = formatValue(key, value, boolean, string);
+            }
+            continue;
+        }
+        result[key] = formatValue(key, value, boolean, string);
+    }
+    return result;
+}

package/dist/utils/assert.js

@@ -0,0 +1,19 @@
+export class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}
+export function assertArrayIncludes(actual, expected, msg) {
+    const actualArr = Array.from(actual);
+    const expectedArr = Array.from(expected);
+    for (const item of expectedArr) {
+        assert(actualArr.includes(item), msg + `\nExpected: ${expectedArr}\nActual: ${actualArr}`);
+    }
+}

package/dist/utils/asyncQueue.js

@@ -0,0 +1,56 @@
+import { nextTick } from "./nextTick.js";
+export class AsyncQueue {
+    queue = [];
+    maxQueueLength = Infinity;
+    nextResolve = (_value) => { };
+    nextReject = (_reason) => { };
+    done = false;
+    hasNext = false;
+    constructor(maxQueueLength) {
+        if (maxQueueLength) {
+            this.maxQueueLength = maxQueueLength;
+        }
+    }
+    async next() {
+        await nextTick();
+        if (this.done && this.queue.length === 0) {
+            return Promise.reject("Closed");
+        }
+        return new Promise((resolve, reject) => {
+            if (this.queue.length > 0) {
+                const item = this.queue.shift();
+                if (item) {
+                    return resolve(item);
+                }
+            }
+            this.nextResolve = resolve;
+            this.nextReject = reject;
+            this.hasNext = true;
+        });
+    }
+    close(reason = "closed") {
+        this.done = true;
+        if (this.hasNext) {
+            this.nextReject(reason);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            yield this.next();
+        }
+    }
+    push(item) {
+        if (this.hasNext) {
+            this.nextResolve(item);
+            this.hasNext = false;
+            return;
+        }
+        if (this.queue.length > this.maxQueueLength) {
+            this.queue.shift();
+        }
+        this.queue.push(item);
+    }
+    get isDone() {
+        return this.done;
+    }
+}

package/dist/utils/deferred.js

@@ -0,0 +1,11 @@
+export class Deferred {
+    promise;
+    resolve;
+    reject;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}

package/dist/utils/logger.js

@@ -0,0 +1,29 @@
+export const LogLevel = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    verbose: 3,
+    debug: 4,
+};
+export class Logger {
+    defaultError = console.error;
+    defaultWarn = console.warn;
+    defaultInfo = console.info;
+    defaultVerbose = console.log;
+    defaultDebug = console.log;
+    // deno-lint-ignore no-explicit-any
+    noop = (..._data) => { };
+    error = this.defaultError;
+    warn = this.defaultWarn;
+    info = this.defaultInfo;
+    verbose = this.noop;
+    debug = this.noop;
+    constructor() { }
+    level(logLevel) {
+        this.warn = logLevel > 0 ? this.defaultWarn : this.noop;
+        this.info = logLevel > 1 ? this.defaultInfo : this.noop;
+        this.verbose = logLevel > 2 ? this.defaultVerbose : this.noop;
+        this.debug = logLevel > 3 ? this.defaultDebug : this.noop;
+    }
+}
+export const logger = new Logger();

package/dist/utils/mod.js

@@ -0,0 +1,7 @@
+export { assert } from "./assert.js";
+export { Deferred } from "./deferred.js";
+export { Logger, logger, LogLevel } from "./logger.js";
+export { AsyncQueue } from "./asyncQueue.js";
+export { nextTick } from "./nextTick.js";
+export { parseArgs } from "./args.js";
+export { getArgs } from "./platform.js";

package/dist/utils/nextTick.js

@@ -0,0 +1,3 @@
+export function nextTick() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}

package/dist/utils/platform.js

@@ -0,0 +1,4 @@
+import { argv } from "node:process";
+export function getArgs() {
+    return argv.slice(2);
+}

package/mqttConn/mqttConn.ts

@@ -112,7 +112,10 @@ export class MqttConn implements IMqttConn {
   async send(data: AnyPacket): Promise<void> {
     try {
       await this.conn.write(encode(data));
-    } catch {
+    } catch (err) {
+      if (err instanceof Error) {
+        this._reason = err.message;
+      }
       this.close();
     }
   }

package/node/client.ts

@@ -1,7 +1,9 @@
+// this a NodeJS specific implementation of TCP client sockets
+// it extends the platform agnostic Client class
 import { Client } from "../client/client.ts";
 import { logger } from "../client/deps.ts";
 import { readFile } from "node:fs/promises";
-import { connect } from "node:net";
+import { createConnection } from "node:net";
 import * as tls from "node:tls";
 import type { SockConn } from "../socket/socket.ts";
 import { wrapNodeSocket } from "./wrapNodeSocket.ts";
@@ -18,16 +20,29 @@ export async function getCaCerts(filename: string | undefined) {
 }
 
 export class TcpClient extends Client {
-  protected async connectMQTT(hostname: string, port = 1883) {
+  protected connectMQTT(hostname: string, port = 1883): Promise<SockConn> {
     logger.debug({ hostname, port });
-    return wrapNodeSocket(await connect({ host: hostname, port }));
+    return new Promise((resolve, reject) => {
+      const socket = createConnection(
+        { port, host: hostname },
+        () => {
+          logger.debug("Connected to server");
+          resolve(wrapNodeSocket(socket));
+        },
+      );
+      socket.once("error", (err) => {
+        // @ts-ignore the type spec of err is missing err.code
+        logger.debug("Connection failed: ", err);
+        reject(err);
+      });
+    });
   }
 
-  protected async connectMQTTS(
+  protected connectMQTTS(
     hostname: string,
     port = 8883,
     caCerts?: string[],
-  ) {
+  ): Promise<SockConn> {
     const opts = {
       host: hostname,
       port,
@@ -36,7 +51,16 @@ export class TcpClient extends Client {
         : undefined,
     };
     logger.debug({ hostname, port, caCerts });
-    return wrapNodeSocket(await tls.connect(opts));
+    return new Promise((resolve, reject) => {
+      const socket = tls.connect(opts, () => {
+        logger.debug("Connected to server");
+        resolve(wrapNodeSocket(socket));
+      });
+      socket.once("error", (err) => {
+        logger.debug("Connection failed", err);
+        reject(err);
+      });
+    });
   }
 
   protected override createConn(

package/node/server.ts

@@ -1,3 +1,5 @@
+// This a NodeJS specific implementation of a TCP socket listener
+// it uses the platform agnostic MqttServer class
 import type { Server } from "node:net";
 import { createServer } from "node:net";
 import type { MqttServerOptions } from "../server/mod.ts";

package/node/wrapNodeSocket.ts

@@ -47,7 +47,7 @@ export function wrapNodeSocket(socket: Socket): SockConn {
   const conn: SockConn = {
     readable: readable as ReadableStream<Uint8Array>,
     writable: writable as WritableStream<Uint8Array>,
-    closer: () => closer(socket),
+    close: () => closer(socket),
     remoteAddr,
   };
   return conn;

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@seriousme/opifex",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "MQTT client & server for Deno & NodeJS",
   "type": "module",
   "scripts": {
     "test": "node --experimental-strip-types --test --test-skip-pattern='/^Deno/'",
-    "build": "npx pkgroll --clean-dist --src .",
-    "postbuild": "deno fmt"
+    "prebuild": "rm -rf dist",
+    "build": "npx -p typescript@beta tsc --build",
+    "postbuild": "deno fmt",
+    "preversion": "npm run test",
+    "version": "npm run build",
+    "postversion": "jq '( { name:.name , version:.version} + .deno)' package.json > deno.json"
   },
   "keywords": [
     "MQTT",
@@ -21,6 +25,15 @@
     "./server": "./dist/server/mod.js",
     "./client": "./dist/client/mod.js"
   },
+  "deno": {
+    "exports": {
+      "./server": "./server/mod.ts",
+      "./client": "./client/mod.ts"
+    },
+    "exclude": [
+      "dist"
+    ]
+  },
   "author": "Hans Klunder",
   "license": "MIT",
   "repository": {

package/server/mod.ts

@@ -1,6 +1,5 @@
 /**
- *  This module provides an MQTT Server interface
- *  see the /bin folder for examples
+ *  This module provides an MQTT Server interface see the /bin folder for examples
  *  @module
  */
 export { AuthenticationResult } from "./deps.ts";

package/socket/socket.ts

@@ -13,7 +13,7 @@ export interface UnixAddr {
 export type SockConn = {
   readable: ReadableStream<Uint8Array>;
   writable: WritableStream<Uint8Array>;
-  closer: () => void;
+  close: () => void;
   localAddr?: SockAddr;
   remoteAddr?: SockAddr;
 };
@@ -29,7 +29,8 @@ export class Conn {
     this.closed = false;
     this.reader = sockConn.readable.getReader({ mode: "byob" });
     this.writer = sockConn.writable.getWriter();
-    this.closer = sockConn.closer;
+    // this.writer.closed.then(() => this.closed = true);
+    this.closer = sockConn.close.bind(sockConn);
     this.remoteAddr = sockConn.remoteAddr;
   }
 

package/timer/timer.ts

@@ -2,7 +2,7 @@ export class Timer {
   readonly delay: number; // delay in microseconds
   // deno-lint-ignore ban-types
   private action: Function; // function to perform when timer expires
-  private timer = 0;
+  private timer?: ReturnType<typeof setTimeout>;
   private end = 0;
   private running = false;
 

package/tsconfig.json

@@ -5,12 +5,15 @@
     "module": "esnext",
     "moduleResolution": "node",
     "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
     "strict": true,
     "outDir": "dist",
     "esModuleInterop": true,
     "isolatedModules": true,
     "skipLibCheck": true
   },
+  "include": ["bin/*.ts"],
   "exclude": [
     "dist",
     "deno",

package/.vscode/extensions.json

@@ -1,10 +0,0 @@
-{
-  // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
-  // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
-
-  // List of extensions which should be recommended for users of this workspace.
-  "recommendations": ["denoland.vscode-deno"],
-
-  // List of extensions recommended by VS Code that should not be recommended for users of this workspace.
-  "unwantedRecommendations": []
-}

package/.vscode/settings.json

@@ -1,12 +0,0 @@
-{
-  "deno.enable": true,
-  "deno.suggest.imports.hosts": {
-    "https://deno.land": true,
-    "https://io": false,
-    "https://d": false,
-    "https://de": false,
-    "https://deno": false,
-    "https://deno.": false,
-    "https://deno.la": false
-  }
-}

package/deno/wrapDenoConn.ts

@@ -1,12 +0,0 @@
-import type { SockConn } from "../socket/socket.ts";
-
-export function wrapDenoConn(denoConn: Deno.Conn) {
-  const conn: SockConn = {
-    readable: denoConn.readable,
-    writable: denoConn.writable,
-    closer: denoConn.close.bind(denoConn),
-    localAddr: denoConn.localAddr,
-    remoteAddr: denoConn.remoteAddr,
-  };
-  return conn;
-}