@seriousme/opifex 1.11.2 → 2.0.3

package/mqttPacket/disconnect.ts

@@ -1,11 +1,7 @@
 import { PacketType } from "./PacketType.ts";
 import { Decoder, hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type {
-  CodecOpts,
-  ProtocolLevelNoV5,
-  TPacketType,
-  TReasonCode,
-} from "./types.ts";
+import type { CodecOpts, TPacketType, TReasonCode } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { DisconnectProperties } from "./Properties.ts";
 import { Encoder } from "./encoder.ts";
 import { ReasonCode } from "./ReasonCode.ts";
@@ -30,71 +26,64 @@ export type DisconnectPacket = DisconnectPacketv4 | DisconnectPacketv5;
 
 const DISCONNECT_PACKET = new Uint8Array([PacketType.disconnect << 4, 0]);
 
-export const disconnect: {
-  encode(_packet: DisconnectPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    _flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): DisconnectPacket;
-} = {
-  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,
-      );
-    }
+export function 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,
-    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();
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: 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,
-      properties,
+      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.ts

@@ -1,10 +1,4 @@
-import type {
-  Topic,
-  TopicFilter,
-  TPacketType,
-  TReasonCode,
-  UTF8StringPair,
-} from "./types.ts";
+import type { TPacketType, TReasonCode, UTF8StringPair } from "./types.ts";
 
 import type {
   Mqttv5PropertyTypes,
@@ -24,7 +18,7 @@ import {
 } from "./Properties.ts";
 
 import { encodeLength } from "./length.ts";
-import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+import { invalidUTF8 } from "./validators.ts";
 import { isValidReasonCode } from "./ReasonCode.ts";
 
 const utf8Encoder = new TextEncoder();
@@ -152,6 +146,9 @@ export class Encoder {
    * @returns The encoder instance for chaining
    */
   setUtf8String(value: string): this {
+    if (invalidUTF8(value)) {
+      throw new EncoderError("Invalid UTF8");
+    }
     this.setByteArray(utf8Encoder.encode(value));
     return this;
   }
@@ -167,38 +164,6 @@ export class Encoder {
     return this;
   }
 
-  /**
-   * Adds an MQTT topic string to the buffer
-   * @param value - Topic string to add
-   * @throws {EncoderError} If topic is invalid
-   * @returns The encoder instance for chaining
-   */
-  setTopic(value: Topic): this {
-    if (invalidTopic(value)) {
-      throw new EncoderError(
-        "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
-      );
-    }
-    this.setUtf8String(value);
-    return this;
-  }
-
-  /**
-   * Adds an MQTT topic filter string to the buffer
-   * @param value - Topic filter string to add
-   * @throws {EncoderError} If topic filter is invalid
-   * @returns The encoder instance for chaining
-   */
-  setTopicFilter(value: TopicFilter): this {
-    if (invalidTopicFilter(value)) {
-      throw new EncoderError(
-        "Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards",
-      );
-    }
-    this.setUtf8String(value);
-    return this;
-  }
-
   /**
    * Adds remaining bytes to the buffer without modification
    * @param value - Array of bytes to add

package/mqttPacket/length.ts

@@ -35,7 +35,7 @@ export function decodeLength(
   const decode = getLengthDecoder();
   const size = buf.length;
   for (let i = start; i < size; i++) {
-    const byte = buf[i];
+    const byte = buf[i] || 0;
     const { done, length, numLengthBytes } = decode(byte);
     if (done) {
       return { length, numLengthBytes };

package/mqttPacket/mod.ts

@@ -5,228 +5,76 @@
  * transformations between binary and object representations.
  */
 
-import type {
-  ClientId,
-  CodecOpts,
-  Dup,
-  PacketId,
-  Payload,
-  ProtocolLevel,
-  QoS,
-  ReturnCodes,
-  TAuthenticationResult,
-  Topic,
-  TopicFilter,
-  TPacketType,
-  TReasonCode,
-  TRetainHandling,
-  UTF8StringPair,
-} from "./types.ts";
+export { decode, decodePayload, encode } from "./codec.ts";
+export type { AnyPacket } from "./codec.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 } from "./connect.ts";
-import { connack } from "./connack.ts";
-import {
-  AuthenticationResult,
-  AuthenticationResultByNumber,
-} from "./AuthenticationResult.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 {
+export type { ConnectPacket } from "./connect.ts";
+export type { ConnackPacket } from "./connack.ts";
+export type { PublishPacket, PublishPacketV5 } from "./publish.ts";
+export type {
+  SubscribePacket,
+  Subscription,
+  SubscriptionV5,
+} from "./subscribe.ts";
+export type { SubackPacket } from "./suback.ts";
+export type { UnsubscribePacket } from "./unsubscribe.ts";
+export type { UnsubackPacket } from "./unsuback.ts";
+export type { PingreqPacket } from "./pingreq.ts";
+export type { PingresPacket } from "./pingres.ts";
+export type { DisconnectPacket } from "./disconnect.ts";
+export type { AuthPacket } from "./auth.ts";
+export 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;
+export { MQTTLevel } from "./protocolLevels.ts";
+export { RetainHandling } from "./RetainHandling.ts";
+export { ReasonCode, ReasonCodeByNumber } from "./ReasonCode.ts";
+export { PacketNameByType, PacketType } from "./PacketType.ts";
+export {
+  AuthenticationResult,
+  AuthenticationResultByNumber,
+} from "./AuthenticationResult.ts";
+export { invalidUTF8 } from "./validators.ts";
+export { decodeLength, encodeLength } from "./length.ts";
+export { getLengthDecoder } from "../mqttPacket/length.ts";
 
+export type { LengthDecoderResult } from "../mqttPacket/length.ts";
 export type {
-  AuthPacket,
   ClientId,
   CodecOpts,
-  ConnackPacket,
-  ConnectPacket,
-  DisconnectPacket,
   Dup,
   PacketId,
   Payload,
-  PingreqPacket,
-  PingresPacket,
-  ProtocolLevel,
-  PubackPacket,
-  PubcompPacket,
-  PublishPacket,
-  PubrecPacket,
-  PubrelPacket,
   QoS,
   ReturnCodes,
-  SubackPacket,
-  SubscribePacket,
   TAuthenticationResult,
   Topic,
   TopicFilter,
   TPacketType,
   TReasonCode,
   TRetainHandling,
-  UnsubackPacket,
-  UnsubscribePacket,
   UTF8StringPair,
-};
-
-export type { Subscription } from "./subscribe.ts";
-
-export {
-  AuthenticationResult,
-  AuthenticationResultByNumber,
-  decodeLength,
-  encodeLength,
-  invalidTopic,
-  invalidTopicFilter,
-  invalidUTF8,
-  PacketNameByType,
-  PacketType,
-};
-
-/**
- * Array mapping MQTT packet types to their corresponding encode/decode handlers
- * Index corresponds to packet type number.
- */
-export 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 TPacketType,
-  );
-  if (packet !== undefined) {
-    return packet;
-  }
-  throw new DecoderError("packet decoding failed");
-}
+} from "./types.ts";
 
-/**
- * @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,
-  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), codecOpts);
-}
+export type {
+  AuthProperties,
+  ConnackProperties,
+  ConnectProperties,
+  DisconnectProperties,
+  PubackProperties,
+  PubcompProperties,
+  PublishProperties,
+  PubrecProperties,
+  PubrelProperties,
+  SubackProperties,
+  SubscribeProperties,
+  UnsubackProperties,
+  UnsubscribeProperties,
+  WillProperties,
+} from "./Properties.ts";
 
-export { getLengthDecoder } from "../mqttPacket/length.ts";
-export type { LengthDecoderResult } from "../mqttPacket/length.ts";
+export type { ProtocolLevel, ProtocolLevelNoV5 } from "./protocolLevels.ts";

package/mqttPacket/pingreq.ts

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

package/mqttPacket/pingres.ts

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

package/mqttPacket/protocolLevels.ts

@@ -2,12 +2,17 @@
  *  MQTT protocol levels
  */
 
-import type { ProtocolLevel } from "./types.ts";
-
-/** available MQTT Protocol levels */
+/** available MQTT Protocol levels
+ * 3.1 = 3
+ * 3.1.1 = 4
+ * 5.0 = 5
+ */
 export const MQTTLevel = {
-  unknown: undefined as ProtocolLevel,
-  v3: 3 as ProtocolLevel,
-  v4: 4 as ProtocolLevel,
-  v5: 5 as ProtocolLevel,
+  unknown: undefined,
+  v3: 3,
+  v4: 4,
+  v5: 5,
 } as const;
+
+export type ProtocolLevel = (typeof MQTTLevel)[keyof typeof MQTTLevel];
+export type ProtocolLevelNoV5 = Exclude<ProtocolLevel, 5>;