@seriousme/opifex 1.1.0

package/mqttPacket/pingreq.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 Pingreq", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pingreq,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      192, // packetType + flags
+      0, // remainingLength
+    ]),
+  );
+});
+
+test("decode Pingreq", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        192, // packetType + flags
+        0, // remainingLength
+      ]),
+    ),
+    {
+      type: PacketType.pingreq,
+    },
+  );
+});
+
+test("decode invalid Pingreq", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          192, // packetType + flags
+          2, // remainingLength
+          0,
+          0,
+        ]),
+      ),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/pingreq.ts

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

package/mqttPacket/pingres.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 Pingres", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pingres,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      208, // packetType + flags
+      0, // remainingLength
+    ]),
+  );
+});
+
+test("decode Pingres", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        208, // packetType + flags
+        0, // remainingLength
+      ]),
+    ),
+    {
+      type: PacketType.pingres,
+    },
+  );
+});
+
+test("decode invalid Pingres", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          208, // packetType + flags
+          2, // remainingLength
+          0,
+          0,
+        ]),
+      ),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/pingres.ts

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

package/mqttPacket/puback.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.puback,
+      id: 1337,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x40, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      5, // id MSB
+      57, // id LSB
+    ]),
+  );
+});
+
+test("decode Puback ", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x40, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    ),
+    {
+      type: PacketType.puback,
+      id: 1337,
+    },
+  );
+});
+
+test("decodeShortPubackPackets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0x40])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0x40, 2])), Error, "too short");
+  assert.throws(
+    () => decode(Uint8Array.from([0x40, 3, 0, 0, 0])),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/puback.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 PubackPacket = {
+  type: TPacketType;
+  id: PacketId;
+};
+
+export default {
+  encode(packet: PubackPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array): PubackPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    decoder.done();
+    return {
+      type: PacketType.puback,
+      id,
+    };
+  },
+};

package/mqttPacket/pubcomp.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 Pubcomp", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pubcomp,
+      id: 1337,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x70, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      5, // id MSB
+      57, // id LSB
+    ]),
+  );
+});
+
+test("decode Pubcomp ", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x70, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    ),
+    {
+      type: PacketType.pubcomp,
+      id: 1337,
+    },
+  );
+});
+
+test("decodeShortPubcompPackets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0x70])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0x70, 2])), Error, "too short");
+  assert.throws(
+    () => decode(Uint8Array.from([0x70, 3, 0, 0, 0])),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/pubcomp.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 PubcompPacket = {
+  type: TPacketType;
+  id: PacketId;
+};
+
+export default {
+  encode(packet: PubcompPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array): PubcompPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    decoder.done();
+    return {
+      type: PacketType.pubcomp,
+      id,
+    };
+  },
+};

package/mqttPacket/publish.test.ts

@@ -0,0 +1,198 @@
+import { PacketType } from "./PacketType.ts";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode } from "./mod.ts";
+
+// const utf8Decoder = new TextDecoder();
+const utf8Encoder = new TextEncoder();
+const payload = utf8Encoder.encode("payload");
+
+test("encode Publish", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.publish,
+      topic: "a/b",
+      payload,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      48, // packetType + flags
+      12, // remainingLength
+      // variableHeader
+      0, // topicLength MSB
+      3, // topicLength LSB
+      97, // 'a'
+      47, // '/'
+      98, // 'b'
+      // payload
+      112, // 'p'
+      97, // 'a'
+      121, // 'y'
+      108, // 'l'
+      111, // 'o'
+      97, // 'a'
+      100, // 'd'
+    ]),
+  );
+});
+
+test("decode Publish", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        48, // packetType + flags
+        12, // remainingLength
+        // variableHeader
+        0, // topicLength MSB
+        3, // topicLength LSB
+        97, // 'a'
+        47, // '/'
+        98, // 'b'
+        // payload
+        112, // 'p'
+        97, // 'a'
+        121, // 'y'
+        108, // 'l'
+        111, // 'o'
+        97, // 'a'
+        100, // 'd'
+      ]),
+    ),
+    {
+      type: PacketType.publish,
+      dup: false,
+      qos: 0,
+      retain: false,
+      id: 0,
+      topic: "a/b",
+      payload: Uint8Array.from([
+        112, // 'p'
+        97, // 'a'
+        121, // 'y'
+        108, // 'l'
+        111, // 'o'
+        97, // 'a'
+        100, // 'd'
+      ]),
+    },
+  );
+});
+
+test("decode Publish with extra bytes", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        48, // packetType + flags
+        12, // remainingLength
+        // variableHeader
+        0, // topicLength MSB
+        3, // topicLength LSB
+        97, // 'a'
+        47, // '/'
+        98, // 'b'
+        // payload
+        112, // 'p'
+        97, // 'a'
+        121, // 'y'
+        108, // 'l'
+        111, // 'o'
+        97, // 'a'
+        100, // 'd'
+        101, // 'e'
+        116, // 't'
+        99, // 'c'
+      ]),
+    ),
+    {
+      type: PacketType.publish,
+      dup: false,
+      qos: 0,
+      retain: false,
+      id: 0,
+      topic: "a/b",
+      payload: Uint8Array.from([
+        112, // 'p'
+        97, // 'a'
+        121, // 'y'
+        108, // 'l'
+        111, // 'o'
+        97, // 'a'
+        100, // 'd'
+      ]),
+    },
+  );
+});
+
+test("decode Publish no payload", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        48, // packetType + flags
+        5, // remainingLength
+        // variableHeader
+        0, // topicLength MSB
+        3, // topicLength LSB
+        97, // 'a'
+        47, // '/'
+        98, // 'b'
+        // payload
+      ]),
+    ),
+    {
+      type: PacketType.publish,
+      dup: false,
+      qos: 0,
+      retain: false,
+      id: 0,
+      topic: "a/b",
+      payload: Uint8Array.from([]),
+    },
+  );
+});
+
+test("Invalid qos", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x36, // packetType + flags
+          5, // remainingLength
+          // variableHeader
+          0, // topicLength MSB
+          3, // topicLength LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          // payload
+        ]),
+      ),
+    Error,
+    "Invalid qos",
+  );
+});
+test("Invalid qos for duplicate", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x38, // packetType + flags
+          5, // remainingLength
+          // variableHeader
+          0, // topicLength MSB
+          3, // topicLength LSB
+          97, // 'a'
+          47, // '/'
+          98, // 'b'
+          // payload
+        ]),
+      ),
+    Error,
+    "Invalid qos for possible duplicate",
+  );
+});

package/mqttPacket/publish.ts

@@ -0,0 +1,73 @@
+import type { Payload, QoS, Topic, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { BitMask } from "./BitMask.ts";
+import { Encoder, EncoderError } from "./encoder.ts";
+import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
+
+export type PublishPacket = {
+  type: TPacketType;
+  topic: Topic;
+  payload: Payload;
+  dup?: boolean;
+  retain?: boolean;
+  qos?: QoS;
+  id?: number;
+};
+
+export default {
+  encode(packet: PublishPacket) {
+    const qos = packet.qos || 0;
+
+    const flags = (packet.dup ? BitMask.bit3 : 0) +
+      (qos & 2 ? BitMask.bit2 : 0) +
+      (qos & 1 ? BitMask.bit1 : 0) +
+      (packet.retain ? BitMask.bit0 : 0);
+
+    const encoder = new Encoder();
+    encoder.setTopic(packet.topic);
+
+    if (qos === 1 || qos === 2) {
+      if (typeof packet.id !== "number" || packet.id < 1) {
+        throw new EncoderError("when qos is 1 or 2, packet must have id");
+      }
+      encoder.setInt16(packet.id);
+    }
+    encoder.setRemainder(packet.payload);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array, flags: number): PublishPacket {
+    const dup = booleanFlag(flags, BitMask.bit3);
+    const qos = (flags & 6) >> 1;
+    const retain = booleanFlag(flags, BitMask.bit0);
+
+    if (qos !== 0 && qos !== 1 && qos !== 2) {
+      throw new DecoderError("Invalid qos");
+    }
+
+    if (dup && qos === 0) {
+      throw new DecoderError("Invalid qos for possible duplicate");
+    }
+
+    const decoder = new Decoder(buffer);
+    const topic = decoder.getTopic();
+
+    let id = 0;
+    if (qos > 0) {
+      id = decoder.getInt16();
+    }
+    const payload = decoder.getRemainder();
+
+    // no decoder.done() required because of getRemainder
+
+    return {
+      type: PacketType.publish,
+      topic,
+      payload,
+      dup,
+      retain,
+      qos,
+      id,
+    };
+  },
+};

package/mqttPacket/pubrec.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 Pubrec", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pubrec,
+      id: 1337,
+    }),
+    Uint8Array.from([
+      // fixedHeader
+      0x50, // packetType + flags
+      2, // remainingLength
+      // variableHeader
+      5, // id MSB
+      57, // id LSB
+    ]),
+  );
+});
+
+test("decode Pubrec ", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        0x50, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    ),
+    {
+      type: PacketType.pubrec,
+      id: 1337,
+    },
+  );
+});
+
+test("decodeShortPubrecPackets", () => {
+  assert.throws(
+    () => decode(Uint8Array.from([0x50])),
+    Error,
+    "decoding failed",
+  );
+  assert.throws(() => decode(Uint8Array.from([0x50, 2])), Error, "too short");
+  assert.throws(
+    () => decode(Uint8Array.from([0x50, 3, 0, 0, 0])),
+    Error,
+    "too long",
+  );
+});

package/mqttPacket/pubrec.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 PubrecPacket = {
+  type: TPacketType;
+  id: PacketId;
+};
+
+export default {
+  encode(packet: PubrecPacket) {
+    const flags = 0;
+    const encoder = new Encoder();
+    encoder.setInt16(packet.id);
+    return { flags, bytes: encoder.done() };
+  },
+
+  decode(buffer: Uint8Array): PubrecPacket {
+    const decoder = new Decoder(buffer);
+    const id = decoder.getInt16();
+    decoder.done();
+    return {
+      type: PacketType.pubrec,
+      id,
+    };
+  },
+};