@seriousme/opifex 1.9.4 → 1.11.0

package/mqttPacket/properties.test.ts

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { Encoder } from "./encoder.ts";
+import { Decoder } from "./decoder.ts";
+import { PacketType } from "./PacketType.ts";
+
+test("encoder.setProperties encodes allowed properties for connect", () => {
+  const encoder = new Encoder(PacketType.connect);
+  const props = {
+    sessionExpiryInterval: 60,
+    authenticationMethod: "basic",
+    authenticationData: new Uint8Array([1, 2, 3]),
+    requestProblemInformation: true,
+    requestResponseInformation: false,
+    receiveMaximum: 100,
+    topicAliasMaximum: 10,
+    userProperty: [["key", "value"]],
+    maximumPacketSize: 1024,
+  };
+  encoder.setProperties(props, PacketType.connect, 2048);
+  assert.equal(encoder.encodedSize(), 48);
+});
+
+test("decoder.getProperties decodes allowed properties for connect", () => {
+  const encoder = new Encoder(PacketType.connect);
+  const props = {
+    sessionExpiryInterval: 60,
+    authenticationMethod: "basic",
+    authenticationData: new Uint8Array([1, 2, 3]),
+    requestProblemInformation: true,
+    requestResponseInformation: false,
+    receiveMaximum: 100,
+    topicAliasMaximum: 10,
+    userProperty: [["key1", "value1"], ["key2", "value2"]],
+    maximumPacketSize: 1024,
+  };
+  encoder.setProperties(props, PacketType.connect, 2048);
+  const buf = encoder.done(0);
+  // skip the first byte which contains the packet identifier
+  // and the second byte that holds the packet length
+  const decoder = new Decoder(PacketType.connect, buf, 2);
+  const decoded = decoder.getProperties(PacketType.connect);
+  assert.equal(decoded.sessionExpiryInterval, 60);
+  assert.equal(decoded.authenticationMethod, "basic");
+  assert.deepEqual(decoded.authenticationData, new Uint8Array([1, 2, 3]));
+  assert.equal(decoded.requestProblemInformation, true);
+  assert.equal(decoded.requestResponseInformation, false);
+  assert.equal(decoded.receiveMaximum, 100);
+  assert.equal(decoded.topicAliasMaximum, 10);
+  assert.deepEqual(decoded.userProperty, [["key1", "value1"], [
+    "key2",
+    "value2",
+  ]]);
+  assert.equal(decoded.maximumPacketSize, 1024);
+});
+
+test("decoder.getProperties decodes allowed properties for connack", () => {
+  const encoder = new Encoder(PacketType.connack);
+  const props = {
+    maximumQos: 2,
+    reasonString: "very good reason",
+  };
+  encoder.setProperties(props, PacketType.connack, 2048);
+  const buf = encoder.done(0);
+  // skip the first byte which contains the packet identifier
+  // and the second byte that holds the packet length
+  const decoder = new Decoder(PacketType.connack, buf, 2);
+  const decoded = decoder.getProperties(PacketType.connack);
+  assert.equal(decoded.maximumQos, 2);
+});
+
+test("encoder.setProperties does not encode properties not allowed for packet type", () => {
+  const encoder = new Encoder(PacketType.publish);
+  const props = {
+    userProperty: [["key", "value"]],
+    // Not allowed for publish
+    sessionExpiryInterval: 60,
+    authenticationMethod: "basic",
+    authenticationData: new Uint8Array([1, 2, 3]),
+    requestProblemInformation: true,
+    requestResponseInformation: false,
+    receiveMaximum: 100,
+    topicAliasMaximum: 10,
+    maximumPacketSize: 1024,
+  };
+  encoder.setProperties(props, PacketType.publish, 2048);
+  const buf = encoder.done(0);
+  const decoder = new Decoder(PacketType.publish, buf, 2);
+  const decoded = decoder.getProperties(PacketType.publish);
+  assert.deepStrictEqual(Object.keys(decoded), [
+    "userProperty",
+  ]);
+});
+
+test("decoder.getProperties throws on duplicate property", () => {
+  const encoder = new Encoder(PacketType.publish);
+  // Manually encode duplicate properties
+  encoder.setVariableByteInteger(0x04); // propertyLength
+  encoder.setVariableByteInteger(0x01); // payloadFormatIndicator
+  encoder.setByte(1);
+  encoder.setVariableByteInteger(0x01); // payloadFormatIndicator again
+  encoder.setByte(1);
+  const buf = encoder.done(0);
+  const decoder = new Decoder(PacketType.publish, buf, 2);
+  assert.throws(
+    () => decoder.getProperties(PacketType.publish),
+    /Property payloadFormatIndicator only allowed once/,
+  );
+});
+
+test("decoder.getProperties throws on property not allowed for packet type", () => {
+  const encoder = new Encoder(PacketType.publish);
+  encoder.setVariableByteInteger(0x05); // propertyLength
+  encoder.setVariableByteInteger(0x13); // serverKeepAlive (not allowed for publish)
+  encoder.setInt32(30);
+  const buf = encoder.done(0);
+  const decoder = new Decoder(PacketType.publish, buf, 2);
+  assert.throws(
+    () => decoder.getProperties(PacketType.publish),
+    /Property type serverKeepAlive not allowed/,
+  );
+});
+
+test("encoder.setProperties rewinds marker if encodedSize exceeds maximumPacketSize", () => {
+  const encoder = new Encoder(PacketType.puback);
+  const props = {
+    reasonString: "small",
+    userProperty: [["key", "value"]],
+  };
+  encoder.setProperties(props, PacketType.puback, 10); // very small max size
+  assert.equal(encoder.encodedSize(), 9);
+});
+
+test("encoder.setProperties removes all properties if encodedSize exceeds maximumPacketSize", () => {
+  const encoder = new Encoder(PacketType.puback);
+  const props = {
+    reasonString: "a very long reason",
+    userProperty: [["key", "value"]],
+  };
+  encoder.setProperties(props, PacketType.puback, 10); // very small max size
+  assert.equal(encoder.encodedSize(), 1); // only propertyLength 0 remains
+});
+
+test("decodeProperty throws on invalid property kind", () => {
+  const encoder = new Encoder(PacketType.publish);
+  // Manually encode an invalid property kind
+  encoder.setVariableByteInteger(0x02); // propertyLength
+  encoder.setVariableByteInteger(0xF0); // Invalid property ID
+  encoder.setByte(1);
+
+  const buf = encoder.done(0);
+  const decoder = new Decoder(PacketType.publish, buf, 2);
+
+  assert.throws(
+    () => decoder.getProperties(PacketType.publish),
+    /Property type 240 not allowed/,
+  );
+});
+
+test("userProperty must be an array", () => {
+  const encoder = new Encoder(PacketType.puback);
+  const props = {
+    userProperty: "I am not an array",
+  };
+  assert.throws(
+    () => encoder.setProperties(props, PacketType.puback, 10),
+    / userProperty must be an array/,
+  );
+});
+
+test("userProperty item must be an array", () => {
+  const encoder = new Encoder(PacketType.puback);
+  const props = {
+    userProperty: ["a", "b"],
+  };
+  assert.throws(
+    () => encoder.setProperties(props, PacketType.puback, 10),
+    / userProperty item must be an array/,
+  );
+});
+
+test("encode/decode subscriptionIdentifiers", () => {
+  const props = { subscriptionIdentifiers: [3, 5, 7] };
+  const bytes = new Uint8Array([48, 7, 6, 0xb, 3, 0xb, 5, 0xb, 7]);
+  const encoder = new Encoder(PacketType.publish);
+  encoder.setProperties(props, PacketType.publish, 1000);
+  const buf = encoder.done(0);
+  assert.deepStrictEqual(buf, bytes);
+  const decoder = new Decoder(PacketType.publish, buf, 2);
+  const decoded = decoder.getProperties(PacketType.publish);
+  assert.deepStrictEqual(decoded, props);
+});

package/mqttPacket/protocolLevels.ts

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

package/mqttPacket/pubblishAcks.ts

@@ -0,0 +1,123 @@
+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";
+
+export type AckPacketV4<T> = {
+  type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
+  id: PacketId;
+};
+
+export type AckPacketV5<T> = {
+  type: TPacketType;
+  protocolLevel: 5;
+  id: PacketId;
+  reasonCode?: TReasonCode;
+  properties?: PubackProperties;
+};
+/**
+ * all 4 ack packets are identical except for packet type and flags of Pubrel
+ */
+export type AckPacket<T> = AckPacketV4<T> | AckPacketV5<T>;
+/**
+ * PubackPacket is sent to indicate publish complete (QoS 1)
+ */
+export type PubackPacket = AckPacket<typeof PacketType.puback>;
+/**
+ * Pubrec is sent to indicate publish received (QoS 2)
+ */
+export type PubrecPacket = AckPacket<typeof PacketType.pubrec>;
+/**
+ * Pubrel is sent to indicate publish release (QoS 2)
+ */
+export type PubrelPacket = AckPacket<typeof PacketType.pubrel>;
+/**
+ * Pubcomp is sent to indicate publish complete (QoS 2)
+ */
+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,
+    };
+  },
+};