@seriousme/opifex 1.11.3 → 2.1.0

package/mqttPacket/disconnect.ts

@@ -1,24 +1,20 @@
 import { PacketType } from "./PacketType.ts";
 import { Decoder, hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type {
-  CodecOpts,
-  ProtocolLevelNoV5,
-  TPacketType,
-  TReasonCode,
-} from "./types.ts";
+import type { CodecOpts } 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";
 
 export type DisconnectPacketv4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
 };
 
 export type DisconnectPacketv5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
-  reasonCode: TReasonCode;
+  reasonCode: ReasonCode;
   properties?: DisconnectProperties;
 };
 
@@ -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
+    .seReasonCode(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: PacketType,
+): 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.geReasonCode();
+  const properties = decoder.getProperties(PacketType.disconnect);
+  decoder.done();
+  return {
+    type: PacketType.disconnect,
+    protocolLevel: 5,
+    reasonCode,
+    properties,
+  };
+}

package/mqttPacket/encoder.test.ts

@@ -51,13 +51,13 @@ test("encode string", () => {
 test("encode reasonCode", () => {
   const reasonCode = ReasonCode.success;
   const encoder = new Encoder(PacketType.connack);
-  encoder.setReasonCode(reasonCode);
+  encoder.seReasonCode(reasonCode);
   assert.deepStrictEqual(encoder.done(0), new Uint8Array([32, 1, reasonCode]));
 });
 
 test("encode invalid reasonCode", () => {
   const encoder = new Encoder(PacketType.connack);
   assert.throws(() => {
-    encoder.setReasonCode(ReasonCode.noMatchingSubscribers);
+    encoder.seReasonCode(ReasonCode.noMatchingSubscribers);
   }, /Reason code 16 not allowed for packet type 2/);
 });

package/mqttPacket/encoder.ts

@@ -1,16 +1,10 @@
-import type {
-  Topic,
-  TopicFilter,
-  TPacketType,
-  TReasonCode,
-  UTF8StringPair,
-} from "./types.ts";
+import type { UTF8StringPair } from "./types.ts";
 
 import type {
   Mqttv5PropertyTypes,
+  PropertySetType,
   PropsByPacketSetType,
   SubscriptionIdentifiersType,
-  TPropertySetType,
   UserPropertyType,
   ValidPropertyNumber,
 } from "./Properties.ts";
@@ -23,8 +17,10 @@ import {
   propertyToKind,
 } from "./Properties.ts";
 
+import type { PacketType } from "./PacketType.ts";
+import type { ReasonCode } from "./ReasonCode.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();
@@ -50,7 +46,7 @@ export class Encoder {
   private numBytes: number;
 
   /** Packet type */
-  private packetType: TPacketType;
+  private packetType: PacketType;
 
   /** marker to rewind to */
   private marker: number;
@@ -58,7 +54,7 @@ export class Encoder {
   /**
    * Creates a new Encoder instance
    */
-  constructor(packetType: TPacketType) {
+  constructor(packetType: PacketType) {
     this.buffers = [];
     this.numBytes = 0;
     this.packetType = packetType;
@@ -152,6 +148,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 +166,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
@@ -288,9 +255,9 @@ export class Encoder {
    * @param propertySetType - the type of packet to encode for
    * @param maximumPacketSize - the maximum packet size to be consumed by properties
    */
-  setProperties<T extends TPropertySetType>(
+  setProperties<T extends PropertySetType>(
     props: PropsByPacketSetType[T],
-    propertySetType: TPropertySetType,
+    propertySetType: PropertySetType,
     maximumPacketSize: number,
   ) {
     const propsEncoder = new Encoder(0);
@@ -317,7 +284,7 @@ export class Encoder {
     propsEncoder.addToEncoder(this);
   }
 
-  setReasonCode(reasonCode: TReasonCode) {
+  seReasonCode(reasonCode: ReasonCode) {
     if (!isValidReasonCode(this.packetType, reasonCode)) {
       throw new EncoderError(
         `Reason code ${reasonCode} not allowed for packet type ${this.packetType}`,

package/mqttPacket/mod.ts

@@ -5,228 +5,72 @@
  * 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] || 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,41 +1,35 @@
 import { PacketType } from "./PacketType.ts";
 import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { CodecOpts, ProtocolLevel, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
+import type { ProtocolLevel } from "./protocolLevels.ts";
 
 /**
  * PingreqPacket is a packet that is sent to the server to keep the connection alive
  */
 export type PingreqPacket = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevel;
 };
 
 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: PacketType,
+): PingreqPacket {
+  hasEmptyFlags(flags);
+  isEmptyBuf(buffer);
+  return {
+    type: PacketType.pingreq,
+    protocolLevel: codecOpts.protocolLevel,
+  };
+}