@seriousme/opifex 1.1.0

package/mqttPacket/pubrel.test.ts

@@ -0,0 +1,55 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Pubrel", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pubrel,
+      id: 1337,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x60, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      5, // id MSB
+      57, // id LSB
+    ]),
+  );
+});
+
+test("decode Pubrel ", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x60, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    ),
+    {
+      type: PacketType.pubrel,
+      id: 1337,
+    },
+  );
+});
+
+test("decodeShortPubrelPackets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0x60])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0x60, 2])), Error, "too short");
+  assert.throws(
+    () => decode(Uint8Array.from([0x60, 3, 0, 0, 0])),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/pubrel.ts

@@ -0,0 +1,28 @@
+import type { PacketId, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { Decoder } from "./decoder.ts";
+import { Encoder } from "./encoder.ts";
+
+export type PubrelPacket = {
+  type: TPacketType;
+  id: PacketId;
+};
+
+export default {
+  encode(packet: PubrelPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array): PubrelPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    decoder.done();
+    return {
+      type: PacketType.pubrel,
+      id,
+    };
+  },
+};

package/mqttPacket/suback.test.ts

@@ -0,0 +1,49 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Suback", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.suback,
+      id: 1,
+      returnCodes: [0, 1],
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x90, // packetType + flags
+      4, // remainingLength
+      // variableHeader
+      0, // id MSB
+      1, // id LSB
+      // payload
+      0,
+      1,
+    ]),
+  );
+});
+
+test("decode Suback", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x90, // packetType + flags
+        4, // remainingLength
+        // variableHeader
+        0, // id MSB
+        1, // id LSB
+        // payload
+        0,
+        1,
+      ]),
+    ),
+    {
+      type: PacketType.suback,
+      id: 1,
+      returnCodes: [0, 1],
+    },
+  );
+});

package/mqttPacket/suback.ts

@@ -0,0 +1,41 @@
+import type { PacketId, ReturnCodes, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { Encoder } from "./encoder.ts";
+import { Decoder } from "./decoder.ts";
+
+export type SubackPacket = {
+  type: TPacketType;
+  id: PacketId;
+  returnCodes: ReturnCodes;
+};
+
+export default {
+  encode(packet: SubackPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    encoder.setRemainder(packet.returnCodes);
+
+    return {
+      flags,
+      bytes: encoder.done(),
+    };
+  },
+
+  decode(buffer: Uint8Array): SubackPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    const payload = decoder.getRemainder();
+    const returnCodes = [];
+
+    for (const code of payload) {
+      returnCodes.push(code);
+    }
+
+    return {
+      type: PacketType.suback,
+      id,
+      returnCodes,
+    };
+  },
+};

package/mqttPacket/subscribe.test.ts

@@ -0,0 +1,233 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Subscribe", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.subscribe,
+      id: 1,
+      subscriptions: [
+        { topicFilter: "a/b", qos: 0 },
+        { topicFilter: "c/d", qos: 1 },
+      ],
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x82, // packetType + flags
+      14, // 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, // qos
+      0, // topic filter length MSB
+      3, // topic filter length LSB
+      99, // 'c'
+      47, // '/'
+      100, // 'd'
+      1, // qos
+    ]),
+  );
+});
+
+test("decode Subscribe", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x82, // packetType + flags
+        14, // 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, // qos
+        0, // topic filter length MSB
+        3, // topic filter length LSB
+        99, // 'c'
+        47, // '/'
+        100, // 'd'
+        1, // qos
+      ]),
+    ),
+    {
+      type: PacketType.subscribe,
+      id: 1,
+      subscriptions: [
+        { topicFilter: "a/b", qos: 0 },
+        { topicFilter: "c/d", qos: 1 },
+      ],
+    },
+  );
+});
+
+test("decode Subscribe missing bit 1 flag", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x80, // packetType + flags
+          14, // 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, // qos
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          99, // 'c'
+          47, // '/'
+          100, // 'd'
+          1, // qos
+        ]),
+      ),
+    Error,
+    "Invalid header",
+  );
+});
+
+test("decode Subscribe packet too short", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x82, // packetType + flags
+          14, // 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, // qos
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          99, // 'c'
+          47, // '/'
+          1, // qos
+        ]),
+      ),
+    Error,
+    "Invalid qos",
+  );
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x82, // packetType + flags
+          14, // 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, // qos
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          99, // 'c'
+        ]),
+      ),
+    Error,
+    "too short",
+  );
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x82, // packetType + flags
+          14, // remainingLength
+          // variableHeader
+          0, // id MSB
+          1, // id LSB
+        ]),
+      ),
+    Error,
+    "too short",
+  );
+});
+
+test("decode Subscribe packet invalid packet id with QoS > 0", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x82, // packetType + flags
+          13, // remainingLength
+          // variableHeader
+          0, // id MSB
+          0, // id LSB
+          // payload
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          0, // qos
+          0, // topic filter length MSB
+          2, // topic filter length LSB
+          99, // 'c'
+          47, // '/'
+          1, // qos
+        ]),
+      ),
+    Error,
+    "Invalid packet identifier",
+  );
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x82, // packetType + flags
+          13, // remainingLength
+          // variableHeader
+          0, // id MSB
+          0, // id LSB
+          // payload
+          0, // topic filter length MSB
+          3, // topic filter length LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          0, // qos
+          0, // topic filter length MSB
+          2, // topic filter length LSB
+          99, // 'c'
+          47, // '/'
+          2, // qos
+        ]),
+      ),
+    Error,
+    "Invalid packet identifier",
+  );
+});

package/mqttPacket/subscribe.ts

@@ -0,0 +1,69 @@
+import type { PacketId, QoS, 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 SubscribePacket = {
+  type: TPacketType;
+  id: PacketId;
+  subscriptions: Subscription[];
+};
+
+export type Subscription = {
+  topicFilter: TopicFilter;
+  qos: QoS;
+};
+
+export default {
+  encode(packet: SubscribePacket) {
+    // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE 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.8.1-1].
+    const flags = 0b0010;
+
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    for (const sub of packet.subscriptions) {
+      encoder.setTopic(sub.topicFilter);
+      encoder.setByte(sub.qos);
+    }
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array, flags: number): SubscribePacket {
+    // Bits 3,2,1 and 0 of the fixed header of the SUBSCRIBE 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.8.1-1].
+    if (!booleanFlag(flags, BitMask.bit1)) {
+      throw new DecoderError("Invalid header");
+    }
+
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+
+    const subscriptions: Subscription[] = [];
+    // The payload of a SUBSCRIBE packet MUST contain at least one Topic Filter / QoS pair.
+    // A SUBSCRIBE packet with no payload is a protocol violation [MQTT-3.8.3-3].
+    do {
+      const topicFilter = decoder.getTopicFilter();
+      const qos = decoder.getByte();
+      if (qos !== 0 && qos !== 1 && qos !== 2) {
+        throw new DecoderError("Invalid qos");
+      }
+      if (qos > 0 && id === 0) {
+        throw new DecoderError("Invalid packet identifier");
+      }
+      subscriptions.push({
+        topicFilter: topicFilter,
+        qos,
+      });
+    } while (!decoder.atEnd());
+    decoder.done();
+    return {
+      type: PacketType.subscribe,
+      id,
+      subscriptions,
+    };
+  },
+};

package/mqttPacket/types.ts

@@ -0,0 +1,27 @@
+import type { BitMask } from "./BitMask.ts";
+import type { PacketType } from "./PacketType.ts";
+import type { AuthenticationResult } from "./AuthenticationResult.ts";
+
+export type TBitMask = typeof BitMask[keyof typeof BitMask];
+export type TPacketType = typeof PacketType[keyof typeof PacketType];
+export type TAuthenticationResult =
+  typeof AuthenticationResult[keyof typeof AuthenticationResult];
+
+export type QoS = 0 | 1 | 2;
+
+export type Payload = Uint8Array;
+
+/**
+ * The MQTT topic to publish or subscribe to
+ */
+export type Topic = string;
+
+export type TopicFilter = string;
+
+export type Dup = boolean;
+
+export type PacketId = number;
+
+export type ReturnCodes = number[];
+
+export type ClientId = string;

package/mqttPacket/unsuback.test.ts

@@ -0,0 +1,55 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+test("encode Puback", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.unsuback,
+      id: 1337,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0xb0, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      5, // id MSB
+      57, // id LSB
+    ]),
+  );
+});
+
+test("decode Puback ", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0xb0, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    ),
+    {
+      type: PacketType.unsuback,
+      id: 1337,
+    },
+  );
+});
+
+test("decodeShortPubackPackets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0xb0])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0xb0, 2])), Error, "too short");
+  assert.throws(
+    () => decode(Uint8Array.from([0xb0, 3, 0, 0, 0])),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/unsuback.ts

@@ -0,0 +1,28 @@
+import type { PacketId, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { Decoder } from "./decoder.ts";
+import { Encoder } from "./encoder.ts";
+
+export type UnsubackPacket = {
+  type: TPacketType;
+  id: PacketId;
+};
+
+export default {
+  encode(packet: UnsubackPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array): UnsubackPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    decoder.done();
+    return {
+      type: PacketType.unsuback,
+      id,
+    };
+  },
+};