@seriousme/opifex 1.9.4 → 1.11.0

package/mqttPacket/publish.test.ts

@@ -2,19 +2,39 @@ import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
-import { decode, encode } from "./mod.ts";
+import { decode, encode, MQTTLevel } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
+
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
 
 // const utf8Decoder = new TextDecoder();
 const utf8Encoder = new TextEncoder();
 const payload = utf8Encoder.encode("payload");
 
-test("encode Publish", () => {
+test("encode/decode short Publish v4", () => {
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: MQTTLevel.v4,
+    qos: 0,
+    dup: false,
+    id: undefined,
+    retain: false,
+    topic: "a/b",
+    payload,
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.publish,
-      topic: "a/b",
-      payload,
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       48, // packetType + flags
@@ -35,123 +55,85 @@ test("encode Publish", () => {
       100, // 'd'
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-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", () => {
+test("encode/decode extended Publish v4", () => {
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: MQTTLevel.v4,
+    dup: false,
+    qos: 0,
+    retain: false,
+    id: undefined,
+    topic: "a/b",
+    payload: Uint8Array.from([
+      112, // 'p'
+      97, // 'a'
+      121, // 'y'
+      108, // 'l'
+      111, // 'o'
+      97, // 'a'
+      100, // 'd'
+    ]),
+  };
+  const encoded = encode(packet, codecOptsV4);
   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'
-      ]),
-    },
+    encoded,
+    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'
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode Publish no payload", () => {
+test("encode/decode Publish v4 no payload", () => {
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: MQTTLevel.v4,
+    dup: false,
+    qos: 0,
+    retain: false,
+    id: undefined,
+    topic: "a/b",
+    payload: Uint8Array.from([]),
+  };
+  const encoded = encode(packet, codecOptsV4);
   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([]),
-    },
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      48, // packetType + flags
+      5, // remainingLength
+      // variableHeader
+      0, // topicLength MSB
+      3, // topicLength LSB
+      97, // 'a'
+      47, // '/'
+      98, // 'b'
+      // payload
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
 test("Invalid qos", () => {
@@ -170,29 +152,126 @@ test("Invalid qos", () => {
           98, // 'b'
           // payload
         ]),
+        codecOptsV4,
       ),
     Error,
     "Invalid qos",
   );
 });
-test("Invalid qos for duplicate", () => {
+
+test("QoS 2, but no packetId", () => {
   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",
+      encode({
+        type: PacketType.publish,
+        protocolLevel: MQTTLevel.v4,
+        topic: "a/b",
+        payload,
+        qos: 2,
+      }, codecOptsV4),
+    /when qos is 1 or 2, packet must have id/,
+  );
+});
+
+test("encode/decode Publish v5", () => {
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: MQTTLevel.v5,
+    dup: false,
+    qos: 0,
+    retain: false,
+    id: undefined,
+    topic: "a/b",
+    payload,
+    properties: {
+      payloadFormatIndicator: true,
+      messageExpiryInterval: 1234,
+      contentType: "content",
+      responseTopic: "response",
+      correlationData: Uint8Array.from([1, 2, 3]),
+      subscriptionIdentifiers: [123],
+      topicAlias: 123,
+      userProperty: [["user", "property"]],
+    },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      48, // packetType + flags
+      69, // remainingLength
+      0, // topic length MSB
+      3, // topic length LSB
+      97, // a
+      47, // /
+      98, // b
+      56, // propertyLength
+      1, // payload format indicator
+      1, // true
+      2, // message expiry interval (4 bytes)
+      0,
+      0,
+      4,
+      210,
+      3, // content type
+      0, // string length MSB
+      7, // string length LSB
+      99, // c
+      111, // o
+      110, // n
+      116, // t
+      101, // e
+      110, // n
+      116, // t
+      8, // response topic
+      0, // string length MSB
+      8, // string length LSB
+      114, // r
+      101, // e
+      115, // s
+      112, // p
+      111, // o
+      110, // n
+      115, // s
+      101, // e
+      9, // correlation data 3 bytes
+      0, // byte length MSB
+      3, // byte length LSB
+      1,
+      2,
+      3,
+      11, // subscriptionIdentifier
+      123, // 123
+      35, // topicAlias
+      0,
+      123,
+      38, // userproperties
+      0, // string length MSB
+      4, // string length LSB
+      117, // u
+      115, // s
+      101, // e
+      114, // r
+      0, // string length MSB
+      8, // string length LSB
+      112, // p
+      114, // r
+      111, // o
+      112, // p
+      101, // e
+      114, // r
+      116, // t
+      121, // y
+      112, // p
+      97, // a
+      121, // y
+      108, // l
+      111, // o
+      97, // a
+      100, // d
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
 });

package/mqttPacket/publish.ts

@@ -1,4 +1,13 @@
-import type { Payload, QoS, Topic, TPacketType } from "./types.ts";
+import type {
+  CodecOpts,
+  Dup,
+  Payload,
+  ProtocolLevelNoV5,
+  QoS,
+  Topic,
+  TPacketType,
+} from "./types.ts";
+import type { PublishProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
 import { Encoder, EncoderError } from "./encoder.ts";
@@ -8,21 +17,40 @@ import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
  * PublishPacket is used to send data from client to server and
  * from server to subscribers
  */
-export type PublishPacket = {
+export type PublishPacketV4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
   topic: Topic;
   payload: Payload;
-  dup?: boolean;
+  dup?: Dup;
   retain?: boolean;
   qos?: QoS;
   id?: number;
 };
+export type PublishPacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  topic: Topic;
+  payload: Payload;
+  dup?: Dup;
+  retain?: boolean;
+  qos?: QoS;
+  id?: number;
+  properties?: PublishProperties;
+};
+
+export type PublishPacket = PublishPacketV4 | PublishPacketV5;
 
 export const publish: {
-  encode(packet: PublishPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, flags: number): PublishPacket;
+  encode(packet: PublishPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): PublishPacket;
 } = {
-  encode(packet: PublishPacket): { flags: number; bytes: number[] } {
+  encode(packet: PublishPacket, codecOpts: CodecOpts): Uint8Array {
     const qos = packet.qos || 0;
 
     const flags = (packet.dup ? BitMask.bit3 : 0) +
@@ -30,7 +58,7 @@ export const publish: {
       (qos & 1 ? BitMask.bit1 : 0) +
       (packet.retain ? BitMask.bit0 : 0);
 
-    const encoder = new Encoder();
+    const encoder = new Encoder(packet.type);
     encoder.setTopic(packet.topic);
 
     if (qos === 1 || qos === 2) {
@@ -39,11 +67,24 @@ export const publish: {
       }
       encoder.setInt16(packet.id);
     }
+
+    if (packet.protocolLevel === 5) {
+      encoder.setProperties(
+        packet.properties || {},
+        PacketType.publish,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    }
     encoder.setRemainder(packet.payload);
-    return { flags, bytes: encoder.done() };
+    return encoder.done(flags);
   },
 
-  decode(buffer: Uint8Array, flags: number): PublishPacket {
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): PublishPacket {
     const dup = booleanFlag(flags, BitMask.bit3);
     const qos = (flags & 6) >> 1;
     const retain = booleanFlag(flags, BitMask.bit0);
@@ -56,19 +97,33 @@ export const publish: {
       throw new DecoderError("Invalid qos for possible duplicate");
     }
 
-    const decoder = new Decoder(buffer);
+    const decoder = new Decoder(packetType, buffer);
     const topic = decoder.getTopic();
 
-    let id = 0;
+    let id = undefined;
     if (qos > 0) {
       id = decoder.getInt16();
     }
-    const payload = decoder.getRemainder();
-
+    if (codecOpts.protocolLevel === 5) {
+      const properties = decoder.getProperties(PacketType.publish);
+      const payload = decoder.getRemainder();
+      return {
+        type: PacketType.publish,
+        protocolLevel: 5,
+        properties,
+        topic,
+        payload,
+        dup,
+        retain,
+        qos,
+        id,
+      };
+    }
     // no decoder.done() required because of getRemainder
-
+    const payload = decoder.getRemainder();
     return {
       type: PacketType.publish,
+      protocolLevel: codecOpts.protocolLevel,
       topic,
       payload,
       dup,

package/mqttPacket/publishAcks.test.ts

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts, TPacketType, TReasonCode } from "./mod.ts";
+
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const packetTypesToTest = [
+  [PacketType.puback, "Puback", ReasonCode.packetIdentifierInUse],
+  [PacketType.pubrec, "Pubrec", ReasonCode.packetIdentifierInUse],
+  [PacketType.pubrel, "Pubrel", ReasonCode.packetIdentifierNotFound],
+  [PacketType.pubcomp, "Pubcomp", ReasonCode.packetIdentifierNotFound],
+];
+for (const item of packetTypesToTest) {
+  const [ackType, label, reasonCode] = item as [
+    TPacketType,
+    string,
+    TReasonCode,
+  ];
+  const ackTypeByte = (ackType << 4) + (ackType === PacketType.pubrel ? 2 : 0);
+  test(`encode/decode ${label} v4`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v4,
+      id: 1337,
+    };
+    const encoded = encode(packet, codecOptsV4);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV4);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test(`encode/decode ${label} v5`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v5,
+      id: 1337,
+      reasonCode,
+      properties: { reasonString: "test" },
+    };
+    const encoded = encode(packet, codecOptsV5);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        11, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+        reasonCode, // reasonCode
+        // properties
+        7, // propertyLength
+        31, // reasonString
+        0, // string length MSB
+        4, // string length LSB
+        116, //'t'
+        101, //'e'
+        115, //'s'
+        116, //'t'
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV5);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test(`encode/decode short ${label} v5`, () => {
+    const packet = {
+      type: ackType,
+      protocolLevel: MQTTLevel.v5,
+      id: 1337,
+      reasonCode: 0,
+    };
+    const encoded = encode(packet, codecOptsV5);
+    assert.deepStrictEqual(
+      encoded,
+      Uint8Array.from([
+        // fixedHeader
+        ackTypeByte, // packetType + flags
+        2, // remainingLength
+        // variableHeader
+        5, // id MSB
+        57, // id LSB
+      ]),
+    );
+    const decoded = decode(encoded, codecOptsV5);
+    assert.deepStrictEqual(decoded, packet);
+  });
+
+  test("decode short puback packets", () => {
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte]), codecOptsV4),
+      Error,
+      "decoding failed",
+    );
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte, 3, 0, 0, 0]), codecOptsV4),
+      Error,
+      "too long",
+    );
+    assert.throws(
+      () => decode(Uint8Array.from([ackTypeByte, 2, 5]), codecOptsV5),
+      Error,
+      "decoding failed",
+    );
+  });
+}