@seriousme/opifex 1.9.4 → 1.10.1

package/mqttPacket/protocolLevels.ts

@@ -0,0 +1,13 @@
+/**
+ *  MQTT protocol levels
+ */
+
+import type { ProtocolLevel } from "./types.ts";
+
+// MQTT Protocol levels
+export const MQTTLevel = {
+  unknown: undefined as ProtocolLevel,
+  v3: 3 as ProtocolLevel,
+  v4: 4 as ProtocolLevel,
+  v5: 5 as ProtocolLevel,
+};

package/mqttPacket/pubblishAcks.ts

@@ -0,0 +1,117 @@
+import type {
+  CodecOpts,
+  PacketId,
+  ProtocolLevelNoV5,
+  TPacketType,
+} from "./types.ts";
+import { ReasonCode, type TReasonCode } from "./ReasonCode.ts";
+import type { PubackProperties } from "./Properties.ts";
+import { PacketType } from "./PacketType.ts";
+import { Decoder, DecoderError } from "./decoder.ts";
+import { Encoder } from "./encoder.ts";
+
+/**
+ * PubackPacket is sent to indicate publish complete (QoS 1)
+ * Pubrec is sent to indicate publish received (QoS 2)
+ * Pubrel is sent to indicate publish release (QoS 2)
+ * Pubcomp is sent to indicate publish complete (QoS 2)
+ *
+ * all 4 packets are identical except for packet type
+ */
+export type AckPacketV4<T> = {
+  type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
+  id: PacketId;
+};
+
+export type AckPacketV5<T> = {
+  type: TPacketType;
+  protocolLevel: 5;
+  id: PacketId;
+  reasonCode?: TReasonCode;
+  properties?: PubackProperties;
+};
+
+export type AckPacket<T> = AckPacketV4<T> | AckPacketV5<T>;
+export type PubackPacket = AckPacket<typeof PacketType.puback>;
+export type PubrecPacket = AckPacket<typeof PacketType.pubrec>;
+export type PubrelPacket = AckPacket<typeof PacketType.pubrel>;
+export type PubcompPacket = AckPacket<typeof PacketType.pubcomp>;
+
+export type AnyAckPacket =
+  | PubackPacket
+  | PubrecPacket
+  | PubrelPacket
+  | PubcompPacket;
+
+export const anyAck: {
+  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): AnyAckPacket;
+} = {
+  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
+    const flags = packet.type === PacketType.pubrel ? 2 : 0;
+    const encoder = new Encoder(packet.type);
+    encoder.setInt16(packet.id);
+    if (packet.protocolLevel === 5) {
+      const reasonCode = packet.reasonCode || ReasonCode.success;
+      // if remaining length is less than 1 the value of 0x00 (success) is used.
+      if (
+        reasonCode === ReasonCode.success &&
+        Object.keys(packet.properties || {}).length === 0
+      ) {
+        return encoder.done(flags);
+      }
+      encoder.setReasonCode(reasonCode);
+      encoder.setProperties(
+        packet.properties || {},
+        packet.type,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    }
+    return encoder.done(flags);
+  },
+
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): AnyAckPacket {
+    const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
+    if (flags !== expectedFlags) {
+      throw new DecoderError("Invalid flags");
+    }
+    const decoder = new Decoder(packetType, buffer);
+    const id = decoder.getInt16();
+    if (codecOpts.protocolLevel !== 5) {
+      decoder.done();
+      return {
+        type: packetType,
+        protocolLevel: codecOpts.protocolLevel,
+        id,
+      };
+    }
+    if (decoder.atEnd()) {
+      return {
+        type: packetType,
+        protocolLevel: 5,
+        id,
+        reasonCode: 0,
+      };
+    }
+    const reasonCode = decoder.getReasonCode();
+    const properties = decoder.getProperties(packetType);
+    return {
+      type: packetType,
+      protocolLevel: 5,
+      id,
+      reasonCode,
+      properties,
+    };
+  },
+};

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,