@seriousme/opifex 1.9.4 → 1.11.0

package/mqttPacket/mod.ts

@@ -7,39 +7,64 @@
 
 import type {
   ClientId,
+  CodecOpts,
   Dup,
   PacketId,
   Payload,
+  ProtocolLevel,
   QoS,
   ReturnCodes,
   TAuthenticationResult,
   Topic,
   TopicFilter,
   TPacketType,
+  TReasonCode,
+  TRetainHandling,
+  UTF8StringPair,
 } from "./types.ts";
+
+export { MQTTLevel } from "./protocolLevels.ts";
+export { RetainHandling } from "./RetainHandling.ts";
+export { ReasonCode, ReasonCodeByNumber } from "./ReasonCode.ts";
 import { PacketNameByType, PacketType } from "./PacketType.ts";
 import { invalidTopic, invalidTopicFilter, invalidUTF8 } from "./validators.ts";
 import { decodeLength, encodeLength } from "./length.ts";
-import { connect, type ConnectPacket } from "./connect.ts";
-import { connack, type ConnackPacket } from "./connack.ts";
+import { connect } from "./connect.ts";
+import { connack } from "./connack.ts";
 import {
   AuthenticationResult,
   AuthenticationResultByNumber,
 } from "./AuthenticationResult.ts";
-import { publish, type PublishPacket } from "./publish.ts";
-import { puback, type PubackPacket } from "./puback.ts";
-import { pubrec, type PubrecPacket } from "./pubrec.ts";
-import { pubrel, type PubrelPacket } from "./pubrel.ts";
-import { pubcomp, type PubcompPacket } from "./pubcomp.ts";
-import { subscribe, type SubscribePacket } from "./subscribe.ts";
-import { suback, type SubackPacket } from "./suback.ts";
-import { unsubscribe, type UnsubscribePacket } from "./unsubscribe.ts";
-import { unsuback, type UnsubackPacket } from "./unsuback.ts";
-import { pingreq, type PingreqPacket } from "./pingreq.ts";
-import { pingres, type PingresPacket } from "./pingres.ts";
-import { disconnect, type DisconnectPacket } from "./disconnect.ts";
+import { publish } from "./publish.ts";
+import { anyAck } from "./pubblishAcks.ts";
+import { subscribe } from "./subscribe.ts";
+import { suback } from "./suback.ts";
+import { unsubscribe } from "./unsubscribe.ts";
+import { unsuback } from "./unsuback.ts";
+import { pingreq } from "./pingreq.ts";
+import { pingres } from "./pingres.ts";
+import { disconnect } from "./disconnect.ts";
+import { auth } from "./auth.ts";
 import { DecoderError } from "./decoder.ts";
 
+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
  */
@@ -57,10 +82,13 @@ export type AnyPacket =
   | UnsubackPacket
   | PingreqPacket
   | PingresPacket
-  | DisconnectPacket;
+  | DisconnectPacket
+  | AuthPacket;
 
 export type {
+  AuthPacket,
   ClientId,
+  CodecOpts,
   ConnackPacket,
   ConnectPacket,
   DisconnectPacket,
@@ -69,6 +97,7 @@ export type {
   Payload,
   PingreqPacket,
   PingresPacket,
+  ProtocolLevel,
   PubackPacket,
   PubcompPacket,
   PublishPacket,
@@ -82,8 +111,11 @@ export type {
   Topic,
   TopicFilter,
   TPacketType,
+  TReasonCode,
+  TRetainHandling,
   UnsubackPacket,
   UnsubscribePacket,
+  UTF8StringPair,
 };
 
 export type { Subscription } from "./subscribe.ts";
@@ -109,10 +141,10 @@ export const packetsByType = [
   connect, // 1
   connack, // 2
   publish, // 3
-  puback, // 4
-  pubrec, // 5
-  pubrel, // 6
-  pubcomp, // 7
+  anyAck, // 4 puback
+  anyAck, // 5 pubrec
+  anyAck, // 6 pubrel
+  anyAck, // 7 pubcomp
   subscribe, // 8
   suback, // 9
   unsubscribe, // 10
@@ -120,36 +152,29 @@ export const packetsByType = [
   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): Uint8Array {
+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);
+  const encoded = packetsByType[packetType]?.encode(pkt, codecOpts);
   if (!encoded) {
     throw Error("Packet encoding failed");
   }
-  const { flags, bytes } = encoded;
-  const encodedLength = encodeLength(bytes.length);
-  const buflenght = 1 + encodedLength.length + bytes.length;
-  const buffer = new Uint8Array(buflenght);
-  let offset = 0;
-  buffer[offset++] = (packetType << 4) | flags;
-  for (let i = 0; i < encodedLength.length; i++) {
-    buffer[offset++] = encodedLength[i];
-  }
-  for (let i = 0; i < bytes.length; i++) {
-    buffer[offset++] = bytes[i];
-  }
-  return buffer;
+  return encoded;
 }
 
 /**
@@ -157,38 +182,50 @@ export function encode(packet: AnyPacket): Uint8Array {
  * @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 {Error} If packet decoding fails
+ * @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);
+  const packet = packetsByType[packetType]?.decode(
+    buffer,
+    flags,
+    codecOpts,
+    packetType as TPacketType,
+  );
   if (packet !== undefined) {
     return packet;
   }
-  throw new Error("packet decoding failed");
+  throw new DecoderError("packet decoding failed");
 }
 
 /**
  * @function decode
  * @description Decodes a complete MQTT packet from binary format into a packet object
+ *
  * @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): AnyPacket {
+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], buffer.subarray(start, end));
+  return decodePayload(buffer[0], buffer.subarray(start, end), codecOpts);
 }
 
 export { getLengthDecoder } from "../mqttPacket/length.ts";

package/mqttPacket/pingreq.test.ts

@@ -2,13 +2,58 @@ 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";
 
-test("encode Pingreq", () => {
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode Pingreq v4", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pingreq,
+      protocolLevel: MQTTLevel.v4,
+    }, codecOptsV4),
+    Uint8Array.from([
+      // fixedHeader
+      192, // packetType + flags
+      0, // remainingLength
+    ]),
+  );
+});
+
+test("decode Pingreq v4", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        192, // packetType + flags
+        0, // remainingLength
+      ]),
+      codecOptsV4,
+    ),
+    {
+      type: PacketType.pingreq,
+      protocolLevel: MQTTLevel.v4,
+    },
+  );
+});
+
+test("encode Pingreq v5", () => {
   assert.deepStrictEqual(
     encode({
       type: PacketType.pingreq,
-    }),
+      protocolLevel: MQTTLevel.v5,
+    }, codecOptsV5),
     Uint8Array.from([
       // fixedHeader
       192, // packetType + flags
@@ -17,7 +62,7 @@ test("encode Pingreq", () => {
   );
 });
 
-test("decode Pingreq", () => {
+test("decode Pingreq v5", () => {
   assert.deepStrictEqual(
     decode(
       Uint8Array.from([
@@ -25,9 +70,11 @@ test("decode Pingreq", () => {
         192, // packetType + flags
         0, // remainingLength
       ]),
+      codecOptsV5,
     ),
     {
       type: PacketType.pingreq,
+      protocolLevel: MQTTLevel.v5,
     },
   );
 });
@@ -43,6 +90,7 @@ test("decode invalid Pingreq", () => {
           0,
           0,
         ]),
+        codecOptsV4,
       ),
     Error,
     "too long",

package/mqttPacket/pingreq.ts

@@ -1,28 +1,41 @@
 import { PacketType } from "./PacketType.ts";
 import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { TPacketType } from "./types.ts";
+import type { CodecOpts, ProtocolLevel, TPacketType } from "./types.ts";
 
 /**
  * PingreqPacket is a packet that is sent to the server to keep the connection alive
  */
 export type PingreqPacket = {
   type: TPacketType;
+  protocolLevel: ProtocolLevel;
 };
 
+const PINGRES_PACKET = new Uint8Array([PacketType.pingreq << 4, 0]);
+
 export const pingreq: {
-  encode(_packet: PingreqPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array, flags: number): PingreqPacket;
+  encode(_packet: PingreqPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    _packetType: TPacketType,
+  ): PingreqPacket;
 } = {
-  encode(_packet: PingreqPacket): { flags: number; bytes: number[] } {
-    const flags = 0;
-    return { flags, bytes: [] };
+  encode(_packet: PingreqPacket, _codecOpts: CodecOpts): Uint8Array {
+    return PINGRES_PACKET;
   },
 
-  decode(buffer: Uint8Array, flags: number): PingreqPacket {
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    _packetType: TPacketType,
+  ): PingreqPacket {
     hasEmptyFlags(flags);
     isEmptyBuf(buffer);
     return {
       type: PacketType.pingreq,
+      protocolLevel: codecOpts.protocolLevel,
     };
   },
 };

package/mqttPacket/pingres.test.ts

@@ -2,13 +2,58 @@ 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";
 
-test("encode Pingres", () => {
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("encode Pingres V4", () => {
+  assert.deepStrictEqual(
+    encode({
+      type: PacketType.pingres,
+      protocolLevel: MQTTLevel.v4,
+    }, codecOptsV4),
+    Uint8Array.from([
+      // fixedHeader
+      208, // packetType + flags
+      0, // remainingLength
+    ]),
+  );
+});
+
+test("decode Pingres V4", () => {
+  assert.deepStrictEqual(
+    decode(
+      Uint8Array.from([
+        // fixedHeader
+        208, // packetType + flags
+        0, // remainingLength
+      ]),
+      codecOptsV4,
+    ),
+    {
+      type: PacketType.pingres,
+      protocolLevel: MQTTLevel.v4,
+    },
+  );
+});
+
+test("encode Pingres V5", () => {
   assert.deepStrictEqual(
     encode({
       type: PacketType.pingres,
-    }),
+      protocolLevel: MQTTLevel.v5,
+    }, codecOptsV5),
     Uint8Array.from([
       // fixedHeader
       208, // packetType + flags
@@ -17,7 +62,7 @@ test("encode Pingres", () => {
   );
 });
 
-test("decode Pingres", () => {
+test("decode Pingres V5", () => {
   assert.deepStrictEqual(
     decode(
       Uint8Array.from([
@@ -25,9 +70,11 @@ test("decode Pingres", () => {
         208, // packetType + flags
         0, // remainingLength
       ]),
+      codecOptsV5,
     ),
     {
       type: PacketType.pingres,
+      protocolLevel: MQTTLevel.v5,
     },
   );
 });
@@ -43,6 +90,7 @@ test("decode invalid Pingres", () => {
           0,
           0,
         ]),
+        codecOptsV4,
       ),
     Error,
     "too long",

package/mqttPacket/pingres.ts

@@ -1,6 +1,6 @@
 import { PacketType } from "./PacketType.ts";
-import { isEmptyBuf } from "./decoder.ts";
-import type { TPacketType } from "./types.ts";
+import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
+import type { CodecOpts, ProtocolLevel, TPacketType } from "./types.ts";
 
 /**
  * PingresPacket is  an empty packet that is sent by the server in response to a PingreqPacket.
@@ -8,21 +8,35 @@ import type { TPacketType } from "./types.ts";
  */
 export type PingresPacket = {
   type: TPacketType;
+  protocolLevel: ProtocolLevel;
 };
 
+const PINGRES_PACKET = new Uint8Array([PacketType.pingres << 4, 0]);
+
 export const pingres: {
-  encode(_packet: PingresPacket): { flags: number; bytes: number[] };
-  decode(buffer: Uint8Array): PingresPacket;
+  encode(packet: PingresPacket, _codecOpts: CodecOpts): Uint8Array;
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    _packetType: TPacketType,
+  ): PingresPacket;
 } = {
-  encode(_packet: PingresPacket): { flags: number; bytes: number[] } {
-    const flags = 0;
-    return { flags, bytes: [] };
+  encode(_packet: PingresPacket, _codecOpts: CodecOpts): Uint8Array {
+    return PINGRES_PACKET;
   },
 
-  decode(buffer: Uint8Array): PingresPacket {
+  decode(
+    buffer: Uint8Array,
+    flags: number,
+    codecOpts: CodecOpts,
+    _packetType: TPacketType,
+  ): PingresPacket {
+    hasEmptyFlags(flags);
     isEmptyBuf(buffer);
     return {
       type: PacketType.pingres,
+      protocolLevel: codecOpts.protocolLevel,
     };
   },
 };