@seriousme/opifex 1.9.3 → 1.10.1

package/mqttPacket/RetainHandling.ts

@@ -0,0 +1,11 @@
+/**
+ *RetainHandling
+ 0 = Send retained messages at the time of the subscribe
+ 1 = Send retained messages at subscribe only if the subscription does not currently exist
+ 2 = Do not send retained messages at the time of the subscribe
+ */
+export const RetainHandling = {
+  sendRetained: 0,
+  ifSubscriptionNotExists: 1,
+  noRetain: 2,
+} as const;

package/mqttPacket/auth.test.ts

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { AuthPacket, CodecOpts } from "./mod.ts";
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("decode Auth V5 with invalid reasonCode", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x20, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          0, // reason code
+          64, // (reserved)
+        ]),
+        codecOptsV5,
+      ),
+    /Invalid reason code/,
+  );
+});
+
+test("decode Auth V5 as V4", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0xf0, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          0, // reason code
+          0, // properties length
+        ]),
+        codecOptsV4,
+      ),
+    /Invalid protocol level/,
+  );
+});
+
+test("encode/decode minimal auth V5", () => {
+  const packet = {
+    protocolLevel: MQTTLevel.v5,
+    type: PacketType.auth,
+    reasonCode: ReasonCode.success,
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+
+      0xf0, // auth packet + flags
+      2, // remaining length
+      0, // reason code
+      0, // property length
+    ]),
+  );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, { ...packet, properties: {} });
+});
+
+test("encode/decode auth V5", () => {
+  const packet: AuthPacket = {
+    protocolLevel: 5,
+    type: PacketType.auth,
+    reasonCode: ReasonCode.continueAuthentication,
+    properties: {
+      userProperty: [["key", "value"]],
+    },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+
+      0xf0, // auth packet + flags
+      15, // remaining length
+      24, // reason code
+      13, // property length
+      38, // user property
+      0, // string MSB
+      3, // string LSB
+      107, // k
+      101, // e
+      121, // y
+      0, // string MSB
+      5, // string LSB
+      118, // v
+      97, // a
+      108, // l
+      117, // u
+      101, // e
+    ]),
+  );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
+});

package/mqttPacket/auth.ts

@@ -0,0 +1,72 @@
+import type { CodecOpts, TPacketType } from "./types.ts";
+import { PacketType } from "./PacketType.ts";
+import { Encoder, EncoderError } from "./encoder.ts";
+import { Decoder, DecoderError, hasEmptyFlags } from "./decoder.ts";
+import type { TReasonCode } from "./ReasonCode.ts";
+import type { AuthProperties } from "./Properties.ts";
+
+/**
+ * An AUTH packet is sent from Client to Server or Server to Client as part of an extended
+ * authentication exchange, such as challenge / response authentication.
+ * It is a Protocol Error for the Client or Server to send an AUTH packet
+ * if the CONNECT packet did not contain the same Authentication Method.
+ */
+
+// AuthPacket does not exist on protocol levels < 5
+export type AuthPacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  reasonCode: TReasonCode;
+  properties?: AuthProperties;
+};
+
+export type AuthPacket = AuthPacketV5;
+
+export const auth: {
+  encode(packet: AuthPacket, codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): AuthPacket;
+} = {
+  encode(packet: AuthPacket, codecOpts: CodecOpts): Uint8Array {
+    if (packet.protocolLevel !== 5) {
+      throw new EncoderError("Invalid protocol level");
+    }
+    const encoder = new Encoder(packet.type);
+    encoder
+      .setReasonCode(packet.reasonCode || 0)
+      .setProperties(
+        packet.properties || {},
+        packet.type,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    return encoder.done(0);
+  },
+
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): AuthPacket {
+    // Bits 3,2,1 and 0 of the Fixed Header of the AUTH packet are reserved and MUST all be set to 0.
+    // The Client or Server MUST treat any other value as malformed and close the Network Connection [MQTT-3.15.1-1].
+    hasEmptyFlags(flags);
+    if (codecOpts.protocolLevel !== 5) {
+      throw new DecoderError("Invalid protocol level");
+    }
+    const decoder = new Decoder(packetType, buffer);
+    const reasonCode = decoder.getReasonCode();
+    const properties = decoder.getProperties(PacketType.auth);
+    decoder.done();
+    return {
+      type: PacketType.auth,
+      protocolLevel: 5,
+      reasonCode,
+      properties,
+    };
+  },
+};

package/mqttPacket/connack.test.ts

@@ -1,53 +1,53 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { decode, encode } from "./mod.ts";
-import { PacketType } from "./PacketType.ts";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { CodecOpts, ConnackPacket } from "./mod.ts";
 
-test("encode Connack packet", () => {
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode/decode Connack packet v4", () => {
+  const packet = {
+    type: PacketType.connack,
+    protocolLevel: MQTTLevel.v4,
+    sessionPresent: false,
+    returnCode: 0,
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.connack,
-      sessionPresent: false,
-      returnCode: 0,
-    }),
-    Uint8Array.from([
+    encoded,
+    Uint8Array.from(Uint8Array.from([
       // fixedHeader
       0x20, // packetType + flags
       2, // remainingLength
       // variableHeader
       0, // connack flags
       0, // return code
-    ]),
-  );
-});
-
-test("decode Connack packet", () => {
-  assert.deepStrictEqual(
-    decode(
-      Uint8Array.from([
-        // fixedHeader
-        0x20, // packetType + flags
-        2, // remainingLength
-        // variableHeader
-        0, // connack flags
-        0, // return code
-      ]),
-    ),
-    {
-      type: PacketType.connack,
-      sessionPresent: false,
-      returnCode: 0,
-    },
+    ])),
   );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
-test("encode Connack with session present", () => {
+test("encode/decode Connack with session present v4", () => {
+  const packet = {
+    type: PacketType.connack,
+    protocolLevel: MQTTLevel.v4,
+    sessionPresent: true,
+    returnCode: 0,
+  };
+  const encoded = encode(packet, codecOptsV4);
   assert.deepStrictEqual(
-    encode({
-      type: PacketType.connack,
-      sessionPresent: true,
-      returnCode: 0,
-    }),
+    encoded,
     Uint8Array.from([
       // fixedHeader
       0x20, // packetType + flags
@@ -57,27 +57,8 @@ test("encode Connack with session present", () => {
       0, // return code
     ]),
   );
-});
-
-test("decode Connack with session present", () => {
-  assert
-    .deepStrictEqual(
-      decode(
-        Uint8Array.from([
-          // fixedHeader
-          0x20, // packetType + flags
-          2, // remainingLength
-          // variableHeader
-          1, // connack flags (sessionPresent)
-          0, // return code
-        ]),
-      ),
-      {
-        type: PacketType.connack,
-        sessionPresent: true,
-        returnCode: 0,
-      },
-    );
+  const decoded = decode(encoded, codecOptsV4);
+  assert.deepStrictEqual(decoded, packet);
 });
 
 test("decode Connack with non-zero returnCode", () => {
@@ -91,8 +72,10 @@ test("decode Connack with non-zero returnCode", () => {
         0, // connack flags
         4, // return code (bad username or password)
       ]),
+      codecOptsV4,
     ),
     {
+      protocolLevel: 4,
       type: PacketType.connack,
       sessionPresent: false,
       returnCode: 4,
@@ -112,18 +95,55 @@ test("decode Connack with invalid returnCode", () => {
           0, // connack flags
           64, // return code (reserved)
         ]),
+        codecOptsV4,
       ),
-    Error,
-    "Invalid return code",
+    /Invalid return code/,
   );
 });
 
 test("decode short Connack packets", () => {
   assert.throws(
-    () => decode(Uint8Array.from([0x20])),
-    Error,
-    "decoding failed",
+    () => decode(Uint8Array.from([0x20]), codecOptsV4),
+    /decoding failed/,
+  );
+  assert.throws(
+    () => decode(Uint8Array.from([0x20, 2]), codecOptsV4),
+    /Packet too short/,
+  );
+  assert.throws(
+    () => decode(Uint8Array.from([0x20, 2, 0]), codecOptsV4),
+    /Packet too long/,
+  );
+});
+
+test("encode/decode connack v5", () => {
+  const packet: ConnackPacket = {
+    protocolLevel: 5,
+    type: PacketType.connack,
+    sessionPresent: false,
+    reasonCode: ReasonCode.badUserNameOrPassword,
+    properties: {
+      userProperty: [["key", "value"]],
+    },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
+});
+
+test("encode/decode connack v5 as v4", () => {
+  const packet: ConnackPacket = {
+    protocolLevel: 5,
+    type: PacketType.connack,
+    sessionPresent: false,
+    reasonCode: ReasonCode.banned,
+    properties: {
+      userProperty: [["key", "value"]],
+    },
+  };
+  const encoded = encode(packet, codecOptsV4);
+  assert.throws(
+    () => decode(encoded, codecOptsV4),
+    /Packet too long/,
   );
-  assert.throws(() => decode(Uint8Array.from([0x20, 2])), Error, "too short");
-  assert.throws(() => decode(Uint8Array.from([0x20, 2, 0])), Error, "too long");
 });

package/mqttPacket/connack.ts

@@ -1,44 +1,108 @@
-import type { TAuthenticationResult, TPacketType } from "./types.ts";
+import type {
+  CodecOpts,
+  ProtocolLevelNoV5,
+  TAuthenticationResult,
+  TPacketType,
+} from "./types.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
-import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
+import { Encoder } from "./encoder.ts";
+import {
+  booleanFlag,
+  Decoder,
+  DecoderError,
+  hasEmptyFlags,
+} from "./decoder.ts";
 import { AuthenticationResultByNumber } from "./AuthenticationResult.ts";
+import type { TReasonCode } from "./ReasonCode.ts";
+import type { ConnackProperties } from "./Properties.ts";
 
 /**
  * ConnackPacket is sent from the server to the client in response to a connect packet.
  * It indicates that the connect is accepted.
  */
-export type ConnackPacket = {
+export type ConnackPacketV4 = {
   type: TPacketType;
+  protocolLevel: ProtocolLevelNoV5;
   sessionPresent: boolean;
   returnCode: TAuthenticationResult;
 };
 
+export type ConnackPacketV5 = {
+  type: TPacketType;
+  protocolLevel: 5;
+  sessionPresent: boolean;
+  reasonCode: TReasonCode;
+  properties?: ConnackProperties;
+};
+
+export type ConnackPacket = ConnackPacketV4 | ConnackPacketV5;
+
 export const connack: {
-  encode(packet: ConnackPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, _flags: number): ConnackPacket | undefined;
+  encode(packet: ConnackPacket, codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): ConnackPacket;
 } = {
-  encode(packet: ConnackPacket): { flags: number; bytes: number[] } {
-    const flags = 0;
-    return {
-      flags,
-      bytes: [packet.sessionPresent ? 1 : 0, packet.returnCode || 0],
-    };
+  encode(packet: ConnackPacket, codecOpts: CodecOpts): Uint8Array {
+    if (packet.protocolLevel !== 5) {
+      return new Uint8Array([
+        packet.type << 4,
+        2,
+        packet.sessionPresent ? 1 : 0,
+        packet.returnCode || 0,
+      ]);
+    }
+    const encoder = new Encoder(packet.type);
+    encoder
+      .setByte(packet.sessionPresent ? 1 : 0)
+      .setReasonCode(packet.reasonCode || 0)
+      .setProperties(
+        packet.properties || {},
+        packet.type,
+        codecOpts.maxOutgoingPacketSize,
+      );
+    return encoder.done(0);
   },
 
-  decode(buffer: Uint8Array, _flags: number): ConnackPacket | undefined {
-    const decoder = new Decoder(buffer);
-
-    const sessionPresent = booleanFlag(decoder.getByte(), BitMask.bit0);
-    const returnCode = decoder.getByte() as TAuthenticationResult;
-    decoder.done();
-    if (!AuthenticationResultByNumber[returnCode]) {
-      throw new DecoderError("Invalid return code");
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    packetType: TPacketType,
+  ): ConnackPacket {
+    const decoder = new Decoder(packetType, buffer);
+    hasEmptyFlags(flags);
+    const ackflags = decoder.getByte();
+    if (ackflags > 1) {
+      throw new DecoderError("Invalid Connect Acknowledge flags");
+    }
+    const sessionPresent = booleanFlag(ackflags, BitMask.bit0);
+    if (codecOpts.protocolLevel !== 5) {
+      const returnCode = decoder.getByte() as TAuthenticationResult;
+      decoder.done();
+      if (!AuthenticationResultByNumber[returnCode]) {
+        throw new DecoderError("Invalid return code");
+      }
+      return {
+        type: PacketType.connack,
+        protocolLevel: codecOpts.protocolLevel,
+        sessionPresent,
+        returnCode,
+      };
     }
+    const reasonCode = decoder.getReasonCode();
+    const properties = decoder.getProperties(PacketType.connack);
+    decoder.done();
     return {
       type: PacketType.connack,
+      protocolLevel: 5,
       sessionPresent,
-      returnCode,
+      reasonCode,
+      properties,
     };
   },
 };