@seriousme/opifex 1.1.0

package/mqttPacket/decoder.test.ts

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { Decoder } from "./decoder.ts";
+
+const utf8encoder = new TextEncoder();
+
+test("decode byte", () => {
+  const byte = 127;
+  const decoder = new Decoder(Uint8Array.from([byte]));
+  assert.deepStrictEqual(decoder.getByte(), byte);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode Int16", () => {
+  const value = 0xf0f2;
+  const msb = 0xf0;
+  const lsb = 0xf2;
+  const decoder = new Decoder(Uint8Array.from([msb, lsb]));
+  assert.deepStrictEqual(decoder.getInt16(), value);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode Int16 with remainder", () => {
+  const value = 0xf0f2;
+  const msb = 0xf0;
+  const lsb = 0xf2;
+  const decoder = new Decoder(Uint8Array.from([msb, lsb, 0xff]));
+  assert.deepStrictEqual(decoder.getInt16(), value, "value is correct");
+  assert.deepStrictEqual(decoder.atEnd(), false);
+});
+
+test("decode byte array", () => {
+  const byteArray = new Array(300);
+  byteArray.fill(127);
+  const len = byteArray.length;
+  const decoder = new Decoder(
+    Uint8Array.from([len >> 8, len & 0xff, ...byteArray]),
+  );
+  assert.deepStrictEqual(decoder.getByteArray(), Uint8Array.from(byteArray));
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode byte array as remainder", () => {
+  const str = "hello world";
+  const byteArray = utf8encoder.encode(str);
+  const decoder = new Decoder(byteArray);
+  assert.deepStrictEqual(decoder.getRemainder(), byteArray);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode byte array as empty remainder", () => {
+  const str = "hello world";
+  const emptyArray = Uint8Array.from([]);
+  const byteArray = utf8encoder.encode(str);
+  const len = byteArray.length;
+  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
+  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  assert.deepStrictEqual(decoder.getRemainder(), emptyArray);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode string", () => {
+  const str = "hello world";
+  const byteArray = utf8encoder.encode(str);
+  const len = byteArray.length;
+  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
+  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("decode topic", () => {
+  const str = "hello world";
+  const byteArray = utf8encoder.encode(str);
+  const len = byteArray.length;
+  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray]));
+  assert.deepStrictEqual(decoder.getTopic(), str);
+  assert.deepStrictEqual(decoder.done(), true);
+});
+
+test("Topic too short", () => {
+  const decoder = new Decoder(Uint8Array.from([0x00, 0]));
+  assert.throws(
+    () => decoder.getTopic(),
+    Error,
+    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
+  );
+});
+
+test("Invalid topic", () => {
+  const decoder = new Decoder(Uint8Array.from([0x00, 0x01, 0x00]));
+  assert.throws(
+    () => decoder.getTopic(),
+    Error,
+    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
+  );
+});
+
+test("Invalid topicFilter", () => {
+  const decoder = new Decoder(Uint8Array.from([0x00, 0x01, 0x00]));
+  assert.throws(
+    () => decoder.getTopic(),
+    Error,
+    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
+  );
+});
+
+test("Buffer too short", () => {
+  const str = "hello world";
+  const byteArray = utf8encoder.encode(str);
+  const len = byteArray.length;
+  const decoder = new Decoder(Uint8Array.from([0x00, len + 1, ...byteArray]));
+  assert.throws(() => decoder.getUtf8String(), Error, "too short");
+});
+
+test("Buffer too long", () => {
+  const str = "hello world";
+  const byteArray = utf8encoder.encode(str);
+  const len = byteArray.length;
+  const decoder = new Decoder(Uint8Array.from([0x00, len, ...byteArray, 0]));
+  assert.deepStrictEqual(decoder.getUtf8String(), str);
+  assert.throws(() => decoder.done(), Error, "too long");
+});

package/mqttPacket/decoder.ts

@@ -0,0 +1,109 @@
+import type { TBitMask, Topic, TopicFilter } from "./types.ts";
+import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+
+const utf8Decoder = new TextDecoder("utf-8");
+
+export function booleanFlag(byte: number, mask: TBitMask): boolean {
+  return !!(byte & mask);
+}
+
+export function isEmptyBuf(buf: Uint8Array): void {
+  if (buf.length > 0) {
+    throw new DecoderError("Packet too long");
+  }
+}
+
+export function hasEmptyFlags(flags: number): void {
+  if (flags !== 0) {
+    throw new DecoderError("Invalid fixed header flags");
+  }
+}
+
+export class DecoderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DecoderError";
+  }
+}
+
+export class Decoder {
+  private buf: Uint8Array;
+  private pos: number;
+  private len: number;
+
+  constructor(buf: Uint8Array, pos: number = 0) {
+    this.buf = buf;
+    this.pos = pos;
+    this.len = buf.length;
+  }
+  checkpos(pos: number): void {
+    if (pos > this.len) {
+      throw new DecoderError("Packet too short");
+    }
+  }
+
+  getByte(): number {
+    this.checkpos(this.pos);
+    return this.buf[this.pos++];
+  }
+
+  getInt16(): number {
+    const msb = this.getByte();
+    const lsb = this.getByte();
+    return (msb << 8) | lsb;
+  }
+
+  getByteArray(): Uint8Array {
+    const len = this.getInt16();
+    const start = this.pos;
+    const end = this.pos + len;
+    this.pos = end;
+    this.checkpos(end);
+    return this.buf.subarray(start, end);
+  }
+
+  getUtf8String(): string {
+    const str = utf8Decoder.decode(this.getByteArray());
+    return str;
+  }
+
+  getTopic(): Topic {
+    const topic = this.getUtf8String();
+    if (invalidTopic(topic)) {
+      throw new DecoderError(
+        "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
+      );
+    }
+    return topic;
+  }
+
+  getTopicFilter(): TopicFilter {
+    const topicFilter = this.getUtf8String();
+    if (invalidTopicFilter(topicFilter)) {
+      throw new DecoderError(
+        "Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards",
+      );
+    }
+    return topicFilter;
+  }
+
+  getRemainder() {
+    const start = this.pos;
+    const end = this.len;
+    this.pos = end;
+    return this.buf.subarray(start, end);
+  }
+
+  atEnd(): boolean {
+    if (this.len === this.pos) {
+      return true;
+    }
+    return false;
+  }
+  done(): boolean {
+    if (this.atEnd()) {
+      return true;
+    }
+    throw new DecoderError("Packet too long");
+  }
+}

package/mqttPacket/disconnect.test.ts

@@ -0,0 +1,50 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Disconnect", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.disconnect,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      224, // packetType + flags
+      0, // remainingLength
+    ]),
+  );
+});
+
+test("decode Disconnect", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        224, // packetType + flags
+        0, // remainingLength
+      ]),
+    ),
+    {
+      type: PacketType.disconnect,
+    },
+  );
+});
+
+test("decode invalid Disconnect", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          224, // packetType + flags
+          2, // remainingLength
+          0,
+          0,
+        ]),
+      ),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/disconnect.ts

@@ -0,0 +1,21 @@
+import { PacketType } from "./PacketType.ts";
+import { isEmptyBuf } from "./decoder.ts";
+import type { TPacketType } from "./types.ts";
+
+export type DisconnectPacket = {
+  type: TPacketType;
+};
+
+export default {
+  encode(_packet: DisconnectPacket) {
+    const flags = 0;
+    return { flags, bytes: [] };
+  },
+
+  decode(buffer: Uint8Array, _flags: number): DisconnectPacket {
+    isEmptyBuf(buffer);
+    return {
+      type: PacketType.disconnect,
+    };
+  },
+};

package/mqttPacket/encoder.test.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { Encoder } from "./encoder.ts";
+
+const utf8Encoder = new TextEncoder();
+
+test("encode byte", () => {
+  const byte = 127;
+  const encoder = new Encoder();
+  encoder.setByte(byte);
+  assert.deepStrictEqual(encoder.done(), [byte]);
+});
+
+test("encode byte array", () => {
+  const byteArray = new Array(300);
+  byteArray.fill(127);
+  const len = byteArray.length;
+  const encoder = new Encoder();
+  encoder.setByteArray(Uint8Array.from(byteArray));
+  assert.deepStrictEqual(encoder.done(), [len >> 8, len & 0xff, ...byteArray]);
+});
+
+test("encode byte array as remainder", () => {
+  const str = "hello world";
+  const byteArray = utf8Encoder.encode(str);
+  const encoder = new Encoder();
+  encoder.setRemainder(byteArray);
+  assert.deepStrictEqual(encoder.done(), [...byteArray]);
+});
+
+test("encode string", () => {
+  const str = "hello world";
+  const byteArray = utf8Encoder.encode(str);
+  const len = byteArray.length;
+  const encoder = new Encoder();
+  encoder.setUtf8String(str);
+  assert.deepStrictEqual(encoder.done(), [0x00, len, ...byteArray]);
+});

package/mqttPacket/encoder.ts

@@ -0,0 +1,72 @@
+const utf8Encoder = new TextEncoder();
+import type { Topic, TopicFilter } from "./types.ts";
+import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+
+export class EncoderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "EncoderError";
+  }
+}
+
+export class Encoder {
+  private buffer: number[];
+
+  constructor() {
+    this.buffer = [];
+  }
+
+  setByte(value: number): this {
+    this.buffer.push(value);
+    return this;
+  }
+
+  setInt16(value: number): this {
+    this.setByte(value >> 8);
+    this.setByte(value & 0xff);
+    return this;
+  }
+
+  setByteArray(value: Uint8Array): this {
+    if (value.length > 0xffff) {
+      throw new EncoderError("More than 0xffff bytes of data");
+    }
+    this.setInt16(value.length);
+    this.buffer.push(...value);
+    return this;
+  }
+
+  setUtf8String(value: string): this {
+    this.setByteArray(utf8Encoder.encode(value));
+    return this;
+  }
+
+  setTopic(value: Topic): this {
+    if (invalidTopic(value)) {
+      throw new EncoderError(
+        "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
+      );
+    }
+    this.setUtf8String(value);
+    return this;
+  }
+
+  setTopicFilter(value: TopicFilter): this {
+    if (invalidTopicFilter(value)) {
+      throw new EncoderError(
+        "Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards",
+      );
+    }
+    this.setUtf8String(value);
+    return this;
+  }
+
+  setRemainder(value: Uint8Array | number[]): this {
+    this.buffer.push(...value);
+    return this;
+  }
+
+  done(): number[] {
+    return this.buffer;
+  }
+}

package/mqttPacket/length.test.ts

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decodeLength as decode, encodeLength as encode } from "./length.ts";
+
+test("encodeLength", function encodeLength() {
+  assert.deepStrictEqual(encode(0), [0x00]);
+  assert.deepStrictEqual(encode(127), [0x7f]);
+  assert.deepStrictEqual(encode(128), [0x80, 0x01]);
+  assert.deepStrictEqual(encode(16_383), [0xff, 0x7f]);
+  assert.deepStrictEqual(encode(16_384), [0x80, 0x80, 0x01]);
+  assert.deepStrictEqual(encode(2_097_151), [0xff, 0xff, 0x7f]);
+  assert.deepStrictEqual(encode(2_097_152), [0x80, 0x80, 0x80, 0x01]);
+  assert.deepStrictEqual(encode(268_435_455), [0xff, 0xff, 0xff, 0x7f]);
+  assert.throws(() => encode(268_435_456), Error, "length encoding failed");
+});
+
+test("decodeLength", function decodeLength() {
+  assert.deepStrictEqual(decode(Uint8Array.from([0x00]), 0), {
+    length: 0,
+    numLengthBytes: 1,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0x7f]), 0), {
+    length: 127,
+    numLengthBytes: 1,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0x80, 0x01]), 0), {
+    length: 128,
+    numLengthBytes: 2,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0xff, 0x7f]), 0), {
+    length: 16_383,
+    numLengthBytes: 2,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0xff, 0x7f, 0xff]), 0), {
+    length: 16_383,
+    numLengthBytes: 2,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0x80, 0x80, 0x01]), 0), {
+    length: 16_384,
+    numLengthBytes: 3,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0xff, 0xff, 0x7f]), 0), {
+    length: 2_097_151,
+    numLengthBytes: 3,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0x80, 0x80, 0x80, 0x01]), 0), {
+    length: 2_097_152,
+    numLengthBytes: 4,
+  });
+  assert.deepStrictEqual(decode(Uint8Array.from([0xff, 0xff, 0xff, 0x7f]), 0), {
+    length: 268_435_455,
+    numLengthBytes: 4,
+  });
+  assert.throws(
+    () => decode(Uint8Array.from([0xff, 0xff, 0xff, 0xff]), 0),
+    Error,
+    "length decoding failed",
+  );
+  assert.throws(
+    () => decode(Uint8Array.from([0xff, 0xff, 0xff, 0xff, 0x7f]), 0),
+    Error,
+    "length decoding failed",
+  );
+  assert.throws(
+    () => decode(Uint8Array.from([0xff]), 0),
+    Error,
+    "length decoding failed",
+  );
+  assert.throws(
+    () => decode(Uint8Array.from([]), 0),
+    Error,
+    "length decoding failed",
+  );
+});

package/mqttPacket/length.ts

@@ -0,0 +1,57 @@
+export function encodeLength(n: number): number[] {
+  const output = [];
+  let x = n;
+  do {
+    let encodedByte = x % 0x80;
+    x = Math.floor(x / 0x80);
+    if (x > 0) {
+      encodedByte = encodedByte | 0x80;
+    }
+    output.push(encodedByte);
+  } while (x > 0);
+  if (output.length > 4) {
+    throw Error("length encoding failed");
+  }
+  return output;
+}
+
+export function decodeLength(
+  buf: Uint8Array,
+  start: number,
+): { length: number; numLengthBytes: number } {
+  const decode = getLengthDecoder();
+  const lenBuf = buf.subarray(start);
+  for (const byte of lenBuf) {
+    const { done, length, numLengthBytes } = decode(byte);
+    if (done) {
+      return { length, numLengthBytes };
+    }
+  }
+  throw Error("length decoding failed");
+}
+
+export type LengthDecoderResult = {
+  done: boolean;
+  length: number;
+  numLengthBytes: number;
+};
+
+export function getLengthDecoder(): (
+  encodedByte: number,
+) => LengthDecoderResult {
+  let numLengthBytes = 1;
+  let length = 0;
+  let multiplier = 1;
+
+  return function addLengthByte(encodedByte: number) {
+    length += (encodedByte & 0x7f) * multiplier;
+    multiplier *= 0x80;
+    if ((encodedByte & 0x80) === 0) {
+      return { done: true, length, numLengthBytes };
+    }
+    if (numLengthBytes++ >= 4) {
+      throw Error("length decoding failed");
+    }
+    return { done: false, length, numLengthBytes };
+  };
+}

package/mqttPacket/mod.ts

@@ -0,0 +1,151 @@
+import type {
+  ClientId,
+  Dup,
+  PacketId,
+  Payload,
+  QoS,
+  ReturnCodes,
+  TAuthenticationResult,
+  Topic,
+  TopicFilter,
+  TPacketType,
+} from "./types.ts";
+import { PacketNameByType, PacketType } from "./PacketType.ts";
+import { invalidTopic, invalidTopicFilter, invalidUTF8 } from "./validators.ts";
+import { decodeLength, encodeLength } from "./length.ts";
+import connect, { type ConnectPacket } from "./connect.ts";
+import connack, { type ConnackPacket } from "./connack.ts";
+import {
+  AuthenticationResult,
+  AuthenticationResultByNumber,
+} from "./AuthenticationResult.ts";
+import publish, { type PublishPacket } from "./publish.ts";
+import puback, { type PubackPacket } from "./puback.ts";
+import pubrec, { type PubrecPacket } from "./pubrec.ts";
+import pubrel, { type PubrelPacket } from "./pubrel.ts";
+import pubcomp, { type PubcompPacket } from "./pubcomp.ts";
+import subscribe, { type SubscribePacket } from "./subscribe.ts";
+import suback, { type SubackPacket } from "./suback.ts";
+import unsubscribe, { type UnsubscribePacket } from "./unsubscribe.ts";
+import unsuback, { type UnsubackPacket } from "./unsuback.ts";
+import pingreq, { type PingreqPacket } from "./pingreq.ts";
+import pingres, { type PingresPacket } from "./pingres.ts";
+import disconnect, { type DisconnectPacket } from "./disconnect.ts";
+import { DecoderError } from "./decoder.ts";
+
+export type AnyPacket =
+  | ConnectPacket
+  | ConnackPacket
+  | PublishPacket
+  | PubackPacket
+  | PubrecPacket
+  | PubrelPacket
+  | PubcompPacket
+  | SubscribePacket
+  | SubackPacket
+  | UnsubscribePacket
+  | UnsubackPacket
+  | PingreqPacket
+  | PingresPacket
+  | DisconnectPacket;
+
+export type {
+  ClientId,
+  ConnackPacket,
+  ConnectPacket,
+  DisconnectPacket,
+  Dup,
+  PacketId,
+  Payload,
+  PingreqPacket,
+  PingresPacket,
+  PubackPacket,
+  PubcompPacket,
+  PublishPacket,
+  PubrecPacket,
+  PubrelPacket,
+  QoS,
+  ReturnCodes,
+  SubackPacket,
+  SubscribePacket,
+  TAuthenticationResult,
+  Topic,
+  TopicFilter,
+  TPacketType,
+  UnsubackPacket,
+  UnsubscribePacket,
+};
+
+export type { Subscription } from "./subscribe.ts";
+
+export {
+  AuthenticationResult,
+  AuthenticationResultByNumber,
+  decodeLength,
+  encodeLength,
+  invalidTopic,
+  invalidTopicFilter,
+  invalidUTF8,
+  PacketNameByType,
+  PacketType,
+};
+
+export const packetsByType = [
+  null,
+  connect, // 1
+  connack, // 2
+  publish, // 3
+  puback, // 4
+  pubrec, // 5
+  pubrel, // 6
+  pubcomp, // 7
+  subscribe, // 8
+  suback, // 9
+  unsubscribe, // 10
+  unsuback, // 11
+  pingreq, // 12
+  pingres, // 13
+  disconnect, // 14
+] as const;
+
+export function encode(packet: AnyPacket) {
+  const packetType: number = packet.type;
+  // deno-lint-ignore no-explicit-any
+  const pkt: any = packet;
+  const encoded = packetsByType[packetType]?.encode(pkt);
+  if (!encoded) {
+    throw Error("Packet encoding failed");
+  }
+  const { flags, bytes } = encoded;
+  return Uint8Array.from([
+    (packetType << 4) | flags,
+    ...encodeLength(bytes.length),
+    ...bytes,
+  ]);
+}
+
+export function decodePayload(
+  firstByte: number,
+  buffer: Uint8Array,
+): AnyPacket {
+  const packetType = firstByte >> 4;
+  const flags = firstByte & 0x0f;
+  const packet = packetsByType[packetType]?.decode(buffer, flags);
+  if (packet !== undefined) {
+    return packet;
+  }
+  throw new Error("packet decoding failed");
+}
+
+export function decode(buffer: Uint8Array): AnyPacket {
+  if (buffer.length < 2) {
+    throw new DecoderError("Packet decoding failed");
+  }
+  const { length, numLengthBytes } = decodeLength(buffer, 1);
+  const start = numLengthBytes + 1;
+  const end = start + length;
+  return decodePayload(buffer[0], buffer.subarray(start, end));
+}
+
+export { getLengthDecoder } from "../mqttPacket/length.ts";
+export type { LengthDecoderResult } from "../mqttPacket/length.ts";