@seriousme/opifex 1.9.4 → 1.10.1

package/mqttPacket/disconnect.test.ts

@@ -1,38 +1,99 @@
-import { PacketType } from "./PacketType.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
-import { decode, encode } from "./mod.ts";
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
 
-test("encode Disconnect", () => {
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Disconnect V4", () => {
+  const packet = {
+    type: PacketType.disconnect,
+    protocolLevel: MQTTLevel.v4,
+  };
+  const encoded = encode({
+    type: PacketType.disconnect,
+    protocolLevel: MQTTLevel.v4,
+  }, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.disconnect,
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       224, // packetType + flags
       0, // remainingLength
     ]),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(
+    decoded,
+    packet,
+  );
 });
 
-test("decode Disconnect", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        224, // packetType + flags
-        0, // remainingLength
-      ]),
-    ),
-    {
-      type: PacketType.disconnect,
+test("encode/decode Disconnect V5", () => {
+  const packet = {
+    type: PacketType.disconnect,
+    protocolLevel: MQTTLevel.v5,
+    reasonCode: ReasonCode.success,
+    properties: {
+      reasonString: "reason",
     },
+  };
+
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      224, // packetType + flags
+      11, // remaining length
+      0, // reasoncode
+      9, // property length
+      31, //reason string
+      0, // string MSB
+      6, // string LSB
+      114, // r
+      101, // e
+      97, // a
+      115, // s
+      111, // o
+      110, // n
+    ]),
+  );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
+});
+
+test("encode/decode Short Disconnect V5", () => {
+  const packet = {
+    type: PacketType.disconnect,
+    protocolLevel: MQTTLevel.v5,
+    reasonCode: ReasonCode.success,
+  };
+
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+      224, // packetType + flags
+      0, // remainingLength
+    ]),
   );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("decode invalid Disconnect", () => {
+test("decode invalid Disconnect v4", () => {
   assert.throws(
     () =>
       decode(
@@ -43,8 +104,26 @@ test("decode invalid Disconnect", () => {
           0,
           0,
         ]),
+        codecOptsV4,
       ),
     Error,
     "too long",
   );
 });
+
+test("decode invalid Disconnect V5, invalid reasonCode", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          224, // packetType + flags
+          2, // remainingLength
+          ReasonCode.grantedQos1, // reason code
+          0, // properties
+        ]),
+        codecOptsV5,
+      ),
+    /Invalid reason code/,
+  );
+});

package/mqttPacket/disconnect.ts

@@ -1,28 +1,100 @@
 import { PacketType } from "./PacketType.ts";
-import { isEmptyBuf } from "./decoder.ts";
-import type { TPacketType } from "./types.ts";
+import { Decoder, hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
+import type {
+  CodecOpts,
+  ProtocolLevelNoV5,
+  TPacketType,
+  TReasonCode,
+} from "./types.ts";
+import type { DisconnectProperties } from "./Properties.ts";
+import { Encoder } from "./encoder.ts";
+import { ReasonCode } from "./ReasonCode.ts";
 
 /**
  * DisconnectPacket is the final control packet sent from the client to the server.
  * It indicates that the client is disconnecting cleanly.
  */
-export type DisconnectPacket = {
+export type DisconnectPacketv4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
 };
 
+export type DisconnectPacketv5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  reasonCode: TReasonCode;
+  properties?: DisconnectProperties;
+};
+
+export type DisconnectPacket = DisconnectPacketv4 | DisconnectPacketv5;
+
+const DISCONNECT_PACKET = new Uint8Array([PacketType.disconnect << 4, 0]);
+
 export const disconnect: {
-  encode(_packet: DisconnectPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, _flags: number): DisconnectPacket;
+  encode(_packet: DisconnectPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    _flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): DisconnectPacket;
 } = {
-  encode(_packet: DisconnectPacket): { flags: number; bytes: number[] } {
-    const flags = 0;
-    return { flags, bytes: [] };
+  encode(packet: DisconnectPacket, codecOpts: CodecOpts): Uint8Array {
+    if (packet.protocolLevel !== 5) {
+      return DISCONNECT_PACKET;
+    }
+    const reasonCode = packet.reasonCode || ReasonCode.normalDisconnection;
+    const encoder = new Encoder(packet.type);
+    // see MQTT v5 3.14.2.1
+    // if remaining length is less than 1 the value of 0x00 (normal disconnect) is used.
+    if (
+      reasonCode === ReasonCode.normalDisconnection &&
+      Object.keys(packet.properties || {}).length === 0
+    ) {
+      return encoder.done(0);
+    }
+    encoder
+      .setReasonCode(reasonCode);
+    if (packet.properties) {
+      encoder.setProperties(
+        packet.properties,
+        packet.type,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    }
+    return encoder.done(0);
   },
 
-  decode(buffer: Uint8Array, _flags: number): DisconnectPacket {
-    isEmptyBuf(buffer);
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts,
+    packetType: TPacketType,
+  ): DisconnectPacket {
+    hasEmptyFlags(flags);
+    if (codecOpts.protocolLevel !== 5) {
+      isEmptyBuf(buffer);
+      return {
+        type: PacketType.disconnect,
+        protocolLevel: codecOpts.protocolLevel,
+      };
+    }
+    const decoder = new Decoder(packetType, buffer);
+    if (decoder.atEnd()) {
+      return {
+        type: PacketType.disconnect,
+        protocolLevel: 5,
+        reasonCode: 0,
+      };
+    }
+    const reasonCode = decoder.getReasonCode();
+    const properties = decoder.getProperties(PacketType.disconnect);
+    decoder.done();
     return {
       type: PacketType.disconnect,
+      protocolLevel: 5,
+      reasonCode,
+      properties,
     };
   },
 };

package/mqttPacket/encoder.test.ts

@@ -2,38 +2,62 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 
 import { Encoder } from "./encoder.ts";
+import { encodeLength } from "./length.ts";
+import { PacketType, ReasonCode } from "./mod.ts";
 
 const utf8Encoder = new TextEncoder();
 
 test("encode byte", () => {
   const byte = 127;
-  const encoder = new Encoder();
+  const encoder = new Encoder(0);
   encoder.setByte(byte);
-  assert.deepStrictEqual(encoder.done(), [byte]);
+  assert.deepStrictEqual(encoder.done(0), new Uint8Array([0, 1, byte]));
 });
 
 test("encode byte array", () => {
   const byteArray = new Array(300);
   byteArray.fill(127);
   const len = byteArray.length;
-  const encoder = new Encoder();
+  const payload = [len >> 8, len & 0xff, ...byteArray];
+  const encodedLength = encodeLength(payload.length);
+  const packet = [0, ...encodedLength, ...payload];
+  const encoder = new Encoder(0);
   encoder.setByteArray(Uint8Array.from(byteArray));
-  assert.deepStrictEqual(encoder.done(), [len >> 8, len & 0xff, ...byteArray]);
+  assert.deepStrictEqual(encoder.done(0), new Uint8Array(packet));
 });
 
 test("encode byte array as remainder", () => {
   const str = "hello world";
   const byteArray = utf8Encoder.encode(str);
-  const encoder = new Encoder();
+  const encodedLength = encodeLength(byteArray.length);
+  const packet = [0, ...encodedLength, ...byteArray];
+  const encoder = new Encoder(0);
   encoder.setRemainder(byteArray);
-  assert.deepStrictEqual(encoder.done(), [...byteArray]);
+  assert.deepStrictEqual(encoder.done(0), new Uint8Array(packet));
 });
 
 test("encode string", () => {
   const str = "hello world";
   const byteArray = utf8Encoder.encode(str);
   const len = byteArray.length;
-  const encoder = new Encoder();
+  const payload = [len >> 8, len & 0xff, ...byteArray];
+  const encodedLength = encodeLength(payload.length);
+  const packet = [0, ...encodedLength, ...payload];
+  const encoder = new Encoder(0);
   encoder.setUtf8String(str);
-  assert.deepStrictEqual(encoder.done(), [0x00, len, ...byteArray]);
+  assert.deepStrictEqual(encoder.done(0), new Uint8Array(packet));
+});
+
+test("encode reasonCode", () => {
+  const reasonCode = ReasonCode.success;
+  const encoder = new Encoder(PacketType.connack);
+  encoder.setReasonCode(reasonCode);
+  assert.deepStrictEqual(encoder.done(0), new Uint8Array([32, 1, reasonCode]));
+});
+
+test("encode invalid reasonCode", () => {
+  const encoder = new Encoder(PacketType.connack);
+  assert.throws(() => {
+    encoder.setReasonCode(ReasonCode.noMatchingSubscribers);
+  }, /Reason code 16 not allowed for packet type 2/);
 });

package/mqttPacket/encoder.ts

@@ -1,7 +1,33 @@
-const utf8Encoder = new TextEncoder();
-import type { Topic, TopicFilter } from "./types.ts";
+import type {
+  Topic,
+  TopicFilter,
+  TPacketType,
+  TReasonCode,
+  UTF8StringPair,
+} from "./types.ts";
+
+import type {
+  Mqttv5PropertyTypes,
+  PropsByPacketSetType,
+  SubscriptionIdentifiersType,
+  TPropertySetType,
+  UserPropertyType,
+  ValidPropertyNumber,
+} from "./Properties.ts";
+
+import {
+  propertyByNumber,
+  PropertyByPropertySetType,
+  propertyKind,
+  propertyToId,
+  propertyToKind,
+} from "./Properties.ts";
+
+import { encodeLength } from "./length.ts";
 import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+import { isValidReasonCode } from "./ReasonCode.ts";
 
+const utf8Encoder = new TextEncoder();
 /**
  * Custom error class for encoding operations
  */
@@ -15,15 +41,51 @@ export class EncoderError extends Error {
 /**
  * Encoder class for MQTT packet encoding
  */
+type bufValue = number[] | Uint8Array;
 export class Encoder {
-  /** Internal buffer to store encoded bytes */
-  private buffer: number[];
+  /** Internal bufferlist to store items */
+  private buffers: bufValue[];
+
+  /** Number of bytes in the buffer */
+  private numBytes: number;
+
+  /** Packet type */
+  private packetType: TPacketType;
+
+  /** marker to rewind to */
+  private marker: number;
 
   /**
    * Creates a new Encoder instance
    */
-  constructor() {
-    this.buffer = [];
+  constructor(packetType: TPacketType) {
+    this.buffers = [];
+    this.numBytes = 0;
+    this.packetType = packetType;
+    this.marker = 0;
+  }
+
+  encodedSize() {
+    return this.numBytes;
+  }
+
+  setMarker() {
+    this.marker = this.buffers.length;
+  }
+
+  rewindToMarker() {
+    while (this.buffers.length > this.marker) {
+      const buf = this.buffers.pop();
+      this.numBytes -= buf?.length || 0;
+    }
+  }
+  /**
+   * @param value
+   */
+  addArray(value: number[] | Uint8Array): this {
+    this.buffers.push(value);
+    this.numBytes += value.length;
+    return this;
   }
 
   /**
@@ -32,7 +94,8 @@ export class Encoder {
    * @returns The encoder instance for chaining
    */
   setByte(value: number): this {
-    this.buffer.push(value);
+    this.buffers.push([value]);
+    this.numBytes++;
     return this;
   }
 
@@ -47,6 +110,27 @@ export class Encoder {
     return this;
   }
 
+  /**
+   * adds a 4 byte integer from the buffer (for v5)
+   * @param value - 32-bit integer to encode and add
+   * @returns The encoder instance for chaining
+   */
+  setInt32(value: number): this {
+    this.setInt16(value >> 16);
+    this.setInt16(value & 0xffff);
+    return this;
+  }
+
+  /**
+   * adds a variable byte integer to the buffer (for v5)
+   * @param value - integer to encode and add
+   * @returns The encoder instance for chaining
+   */
+  setVariableByteInteger(value: number): this {
+    this.addArray(encodeLength(value));
+    return this;
+  }
+
   /**
    * Adds a byte array to the buffer with length prefix
    * @param value - Byte array to add
@@ -58,7 +142,7 @@ export class Encoder {
       throw new EncoderError("More than 0xffff bytes of data");
     }
     this.setInt16(value.length);
-    this.buffer.push(...value);
+    this.addArray(value);
     return this;
   }
 
@@ -72,6 +156,17 @@ export class Encoder {
     return this;
   }
 
+  /**
+   * Adds a UTF-8 string pair from the buffer (for v5)
+   * @param stringPair - UTF8StringPair
+   * @returns The encoder instance for chaining
+   */
+  setUtf8StringPair([name, value]: UTF8StringPair): this {
+    this.setUtf8String(name);
+    this.setUtf8String(value);
+    return this;
+  }
+
   /**
    * Adds an MQTT topic string to the buffer
    * @param value - Topic string to add
@@ -110,7 +205,125 @@ export class Encoder {
    * @returns The encoder instance for chaining
    */
   setRemainder(value: Uint8Array | number[]): this {
-    this.buffer.push(...value);
+    this.addArray(value);
+    return this;
+  }
+
+  /**
+   * add lenght and buffers from this
+   * @param encoder - the encoder to add it to
+   */
+  addToEncoder(encoder: Encoder) {
+    encoder.setVariableByteInteger(this.numBytes);
+    for (const buffer of this.buffers) {
+      encoder.addArray(buffer);
+    }
+  }
+
+  /**
+   * Encode a single property
+   * @param id - the id of the property
+   * @param value  the value of the property
+   * @returns
+   */
+  private setProperty(
+    id: ValidPropertyNumber,
+    value: Mqttv5PropertyTypes,
+  ) {
+    const kind = propertyToKind[id];
+    if (kind === propertyKind.utf8StringPairs) {
+      if (!Array.isArray(value)) {
+        throw new EncoderError("userProperty must be an array");
+      }
+      for (const item of value as UserPropertyType) {
+        if (!Array.isArray(item)) {
+          throw new EncoderError("userProperty item must be an array");
+        }
+        this.setVariableByteInteger(id);
+        this.setUtf8StringPair(item);
+      }
+      return;
+    }
+
+    if (kind === propertyKind.varIntArray) {
+      if (!Array.isArray(value)) {
+        throw new EncoderError("Subscription Identifiers must be an array");
+      }
+      for (const item of value as SubscriptionIdentifiersType) {
+        this.setVariableByteInteger(propertyToId["subscriptionIdentifier"]);
+        this.setVariableByteInteger(item);
+      }
+      return;
+    }
+
+    this.setVariableByteInteger(id);
+    switch (kind) {
+      case propertyKind.boolean:
+        this.setByte(!!value === true ? 1 : 0);
+        break;
+      case propertyKind.byte:
+        this.setByte(value as number);
+        break;
+      case propertyKind.int16:
+        this.setInt16(value as number);
+        break;
+      case propertyKind.int32:
+        this.setInt32(value as number);
+        break;
+      case propertyKind.varInt:
+        this.setVariableByteInteger(value as number);
+        break;
+      case propertyKind.byteArray:
+        this.setByteArray(value as Uint8Array);
+        break;
+      case propertyKind.utf8string:
+        this.setUtf8String(value as string);
+        break;
+    }
+  }
+
+  /**
+   * Encode a set of properties respecting potential size limits
+   * @param props - the properties to encode
+   * @param propertySetType - the type of packet to encode for
+   * @param maximumPacketSize - the maximum packet size to be consumed by properties
+   */
+  setProperties<T extends TPropertySetType>(
+    props: PropsByPacketSetType[T],
+    propertySetType: TPropertySetType,
+    maximumPacketSize: number,
+  ) {
+    const propsEncoder = new Encoder(0);
+    const allowedProps = PropertyByPropertySetType[propertySetType];
+    const maxSize = maximumPacketSize - 1; // propertyLength takes at least a byte
+
+    for (const id of allowedProps) {
+      const label = propertyByNumber[id] as keyof PropsByPacketSetType[T];
+      const value = props[label];
+      if (value !== undefined && value !== null) {
+        if (
+          id === propertyToId.reasonString || id === propertyToId.userProperty
+        ) {
+          propsEncoder.setMarker();
+          propsEncoder.setProperty(id, value as Mqttv5PropertyTypes);
+          if (propsEncoder.encodedSize() > maxSize) {
+            propsEncoder.rewindToMarker();
+          }
+        } else {
+          propsEncoder.setProperty(id, value as Mqttv5PropertyTypes);
+        }
+      }
+    }
+    propsEncoder.addToEncoder(this);
+  }
+
+  setReasonCode(reasonCode: TReasonCode) {
+    if (!isValidReasonCode(this.packetType, reasonCode)) {
+      throw new EncoderError(
+        `Reason code ${reasonCode} not allowed for packet type ${this.packetType}`,
+      );
+    }
+    this.setByte(reasonCode);
     return this;
   }
 
@@ -118,7 +331,19 @@ export class Encoder {
    * Returns the final encoded buffer
    * @returns Array containing all encoded bytes
    */
-  done(): number[] {
-    return this.buffer;
+  done(flags: number): Uint8Array {
+    const packetType = this.packetType;
+    const encodedLength = encodeLength(this.numBytes);
+    const totalLength = 1 + encodedLength.length + this.numBytes;
+    const result = new Uint8Array(totalLength);
+    let pos = 0;
+    result.set([packetType << 4 | flags], pos++);
+    result.set(encodedLength, pos);
+    pos += encodedLength.length;
+    for (const buffer of this.buffers) {
+      result.set(buffer, pos);
+      pos += buffer.length;
+    }
+    return result;
   }
 }

package/mqttPacket/length.ts

@@ -33,8 +33,9 @@ export function decodeLength(
   start: number,
 ): { length: number; numLengthBytes: number } {
   const decode = getLengthDecoder();
-  const lenBuf = buf.subarray(start);
-  for (const byte of lenBuf) {
+  const size = buf.length;
+  for (let i = start; i < size; i++) {
+    const byte = buf[i];
     const { done, length, numLengthBytes } = decode(byte);
     if (done) {
       return { length, numLengthBytes };