@seriousme/opifex 1.11.3 → 2.1.0

package/mqttPacket/ReasonCode.ts

@@ -58,7 +58,8 @@ export const ReasonCode = {
  */
 
 export type ReasonCodeByNumberType = InvertRecord<typeof ReasonCode>;
-export const ReasonCodeByNumber = Object
+/** Map of numeric reason codes to names. */
+export const ReasonCodeByNumber: ReasonCodeByNumberType = Object
   .fromEntries(
     Object.entries(ReasonCode).map(([k, v]) => [v, k]),
   ) as ReasonCodeByNumberType;
@@ -226,14 +227,12 @@ const reasonCodesToString = {
   [0xa2]: "Wildcard Subscriptions not supported",
 } as const;
 
-// Can't import this from types as this would create an import loop
-type TPacketType = typeof PacketType[keyof typeof PacketType];
-export type TReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
-type TReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
+export type ReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
+type ReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
 
 export function reasonCodeToString(
-  packetType: TPacketType,
-  code: TReasonCode,
+  packetType: PacketType,
+  code: ReasonCode,
 ): string {
   if (code === 0) {
     if (packetType === PacketType.disconnect) {
@@ -247,10 +246,10 @@ export function reasonCodeToString(
 }
 
 export function isValidReasonCode(
-  packetType: TPacketType,
+  packetType: PacketType,
   code: number,
 ): boolean {
   const validReasonCodes =
-    ReasonCodebyPacket[packetType as TReasonCodeByPacket] as readonly number[];
+    ReasonCodebyPacket[packetType as ReasonCodeByPacket] as readonly number[];
   return validReasonCodes.includes(code);
 }

package/mqttPacket/RetainHandling.ts

@@ -9,3 +9,8 @@ export const RetainHandling = {
   ifSubscriptionNotExists: 1,
   noRetain: 2,
 } as const;
+
+/**
+ * helper type to limit retain handling values
+ */
+export type RetainHandling = typeof RetainHandling[keyof typeof RetainHandling];

package/mqttPacket/auth.test.ts

@@ -75,7 +75,7 @@ test("encode/decode minimal auth V5", () => {
 
 test("encode/decode auth V5", () => {
   const packet: AuthPacket = {
-    protocolLevel: 5,
+    protocolLevel: MQTTLevel.v5,
     type: PacketType.auth,
     reasonCode: ReasonCode.continueAuthentication,
     properties: {

package/mqttPacket/auth.ts

@@ -1,15 +1,16 @@
-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 { ReasonCode } from "./ReasonCode.ts";
 import type { AuthProperties } from "./Properties.ts";
+import type { CodecOpts } from "./types.ts";
+import { MQTTLevel } from "./protocolLevels.ts";
 
 // AuthPacket does not exist on protocol levels < 5
 export type AuthPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: AuthProperties;
 };
 
@@ -21,51 +22,43 @@ export type AuthPacketV5 = {
  */
 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);
-  },
+export function encode(packet: AuthPacket, codecOpts: CodecOpts): Uint8Array {
+  // deno-coverage-ignore-start
+  if (packet.protocolLevel !== 5) {
+    throw new EncoderError("Invalid protocol level");
+  }
+  // deno-coverage-ignore-stop
+  const encoder = new Encoder(packet.type);
+  encoder
+    .seReasonCode(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,
-    };
-  },
-};
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: PacketType,
+): 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.geReasonCode();
+  const properties = decoder.getProperties(PacketType.auth);
+  decoder.done();
+  return {
+    type: PacketType.auth,
+    protocolLevel: MQTTLevel.v5,
+    reasonCode,
+    properties,
+  };
+}

package/mqttPacket/codec.ts

@@ -0,0 +1,147 @@
+import type { CodecOpts } from "./types.ts";
+import type { PacketType } from "./PacketType.ts";
+import { DecoderError } from "./decoder.ts";
+import { decodeLength } from "./length.ts";
+
+// import encoder/decoder for each packet type
+import * as connect from "./connect.ts";
+import * as connack from "./connack.ts";
+import * as publish from "./publish.ts";
+import * as anyAck from "./pubblishAcks.ts";
+import * as subscribe from "./subscribe.ts";
+import * as suback from "./suback.ts";
+import * as unsubscribe from "./unsubscribe.ts";
+import * as unsuback from "./unsuback.ts";
+import * as pingreq from "./pingreq.ts";
+import * as pingres from "./pingres.ts";
+import * as disconnect from "./disconnect.ts";
+import * as auth from "./auth.ts";
+
+// import the Typescript types of the packet types
+import type { ConnectPacket } from "./connect.ts";
+import type { ConnackPacket } from "./connack.ts";
+import type { PublishPacket } from "./publish.ts";
+import type {
+  PubackPacket,
+  PubcompPacket,
+  PubrecPacket,
+  PubrelPacket,
+} from "./pubblishAcks.ts";
+import type { SubscribePacket } from "./subscribe.ts";
+import type { SubackPacket } from "./suback.ts";
+import type { UnsubscribePacket } from "./unsubscribe.ts";
+import type { UnsubackPacket } from "./unsuback.ts";
+import type { PingreqPacket } from "./pingreq.ts";
+import type { PingresPacket } from "./pingres.ts";
+import type { DisconnectPacket } from "./disconnect.ts";
+import type { AuthPacket } from "./auth.ts";
+
+/**
+ * this can be any possible MQTT packet
+ */
+export type AnyPacket =
+  | ConnectPacket
+  | ConnackPacket
+  | PublishPacket
+  | PubackPacket
+  | PubrecPacket
+  | PubrelPacket
+  | PubcompPacket
+  | SubscribePacket
+  | SubackPacket
+  | UnsubscribePacket
+  | UnsubackPacket
+  | PingreqPacket
+  | PingresPacket
+  | DisconnectPacket
+  | AuthPacket;
+
+/**
+ * Array mapping MQTT packet types to their corresponding encode/decode handlers
+ * Index corresponds to packet type number.
+ */
+const packetsByType = [
+  null,
+  connect, // 1
+  connack, // 2
+  publish, // 3
+  anyAck, // 4 puback
+  anyAck, // 5 pubrec
+  anyAck, // 6 pubrel
+  anyAck, // 7 pubcomp
+  subscribe, // 8
+  suback, // 9
+  unsubscribe, // 10
+  unsuback, // 11
+  pingreq, // 12
+  pingres, // 13
+  disconnect, // 14
+  auth, // 15
+] as const;
+
+/**
+ * @function encode
+ * @description Encodes an MQTT packet object into a binary Uint8Array format
+ * @param {AnyPacket} packet - The MQTT packet object to encode
+ * @param {CodecOpts} codecOpts - options to use during encoding
+ * @returns {Uint8Array} The encoded packet as a binary buffer
+ * @throws {Error} If packet encoding fails
+ */
+export function encode(packet: AnyPacket, codecOpts: CodecOpts): Uint8Array {
+  const packetType: number = packet.type;
+  // deno-lint-ignore no-explicit-any
+  const pkt: any = packet;
+  const encoded = packetsByType[packetType]?.encode(pkt, codecOpts);
+  if (!encoded) {
+    throw Error("Packet encoding failed");
+  }
+  return encoded;
+}
+
+/**
+ * @function decodePayload
+ * @description Decodes a packet payload from binary format into an MQTT packet object
+ * @param {number} firstByte - The first byte of the MQTT packet containing type and flags
+ * @param {Uint8Array} buffer - The binary buffer containing the packet payload
+ * @param {CodecOpts} codecOpts - options to use during encoding
+ * @returns {AnyPacket} The decoded MQTT packet object
+ * @throws {DecoderError} If packet decoding fails
+ */
+export function decodePayload(
+  firstByte: number,
+  buffer: Uint8Array,
+  codecOpts: CodecOpts,
+): AnyPacket {
+  const packetType = firstByte >> 4;
+  const flags = firstByte & 0x0f;
+  const packet = packetsByType[packetType]?.decode(
+    buffer,
+    flags,
+    codecOpts,
+    packetType as PacketType,
+  );
+  if (packet !== undefined) {
+    return packet;
+  }
+  throw new DecoderError("packet decoding failed");
+}
+
+/**
+ * @function decode
+ * @description Decodes a complete MQTT packet from binary format into a packet object,
+ *  its basically a wrapper around decodePayload
+ *
+ * @param {Uint8Array} buffer - The binary buffer containing the complete MQTT packet
+ * @param {CodecOpts} codecOpts - the options for the decoder
+ * @returns {AnyPacket} The decoded MQTT packet object
+ * @throws {DecoderError} If packet decoding fails due to invalid format or insufficient data
+ */
+export function decode(buffer: Uint8Array, codecOpts: CodecOpts): AnyPacket {
+  if (buffer.length < 2) {
+    throw new DecoderError("Packet decoding failed");
+  }
+  const { length, numLengthBytes } = decodeLength(buffer, 1);
+  const start = numLengthBytes + 1;
+  const end = start + length;
+  return decodePayload(buffer[0] || 0, buffer.subarray(start, end), codecOpts);
+}

package/mqttPacket/connack.ts

@@ -1,9 +1,5 @@
-import type {
-  CodecOpts,
-  ProtocolLevelNoV5,
-  TAuthenticationResult,
-  TPacketType,
-} from "./types.ts";
+import type { CodecOpts } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
 import { Encoder } from "./encoder.ts";
@@ -14,21 +10,22 @@ import {
   hasEmptyFlags,
 } from "./decoder.ts";
 import { AuthenticationResultByNumber } from "./AuthenticationResult.ts";
-import type { TReasonCode } from "./ReasonCode.ts";
+import type { AuthenticationResult } from "./AuthenticationResult.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
 import type { ConnackProperties } from "./Properties.ts";
 
 export type ConnackPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   sessionPresent: boolean;
-  returnCode: TAuthenticationResult;
+  returnCode: AuthenticationResult;
 };
 
 export type ConnackPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   sessionPresent: boolean;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: ConnackProperties;
 };
 
@@ -38,71 +35,64 @@ export type ConnackPacketV5 = {
  */
 export type ConnackPacket = ConnackPacketV4 | ConnackPacketV5;
 
-export const connack: {
-  encode(packet: ConnackPacket, codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): ConnackPacket;
-} = {
-  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);
-  },
+export function 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)
+    .seReasonCode(packet.reasonCode || 0)
+    .setProperties(
+      packet.properties || {},
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  return encoder.done(0);
+}
 
-  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);
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: PacketType,
+): 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 AuthenticationResult;
     decoder.done();
+    if (!AuthenticationResultByNumber[returnCode]) {
+      throw new DecoderError("Invalid return code");
+    }
     return {
       type: PacketType.connack,
-      protocolLevel: 5,
+      protocolLevel: codecOpts.protocolLevel,
       sessionPresent,
-      reasonCode,
-      properties,
+      returnCode,
     };
-  },
-};
+  }
+  const reasonCode = decoder.geReasonCode();
+  const properties = decoder.getProperties(PacketType.connack);
+  decoder.done();
+  return {
+    type: PacketType.connack,
+    protocolLevel: 5,
+    sessionPresent,
+    reasonCode,
+    properties,
+  };
+}

package/mqttPacket/connect.test.ts

@@ -289,7 +289,7 @@ test("decode Connect with username and password", () => {
   );
 });
 
-const decodedConnectWithWill = Object.assign({}, decodedConnect);
+const decodedConnectWithWill = structuredClone(decodedConnect);
 decodedConnectWithWill.will = {
   topic: "mywill",
   payload: Uint8Array.from([
@@ -472,7 +472,7 @@ test("encode MQTTv4, clean=false,  no clientId", () => {
         protocolLevel: MQTTLevel.v4,
         clean: false,
       }, codecOptsUnknown),
-    /Client id required for clean session/,
+    /Client id required for non-clean session/,
   );
 });